Billy O'Neal avatar Billy O'Neal committed 1b8759d

Updated to Visual Studio 2012.

Comments (0)

Files changed (68)

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevFind/pevFind.vcxproj

     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
       <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <Link>
       <AdditionalDependencies>wintrust.lib;shlwapi.lib;Sfc.lib;Version.lib;Userenv.lib;cryptlib.lib;%(AdditionalDependencies)</AdditionalDependencies>

pevFind/targetver.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/OPSTRUCT.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 class operation : public criterion
 {
 protected:
-	std::tr1::shared_ptr<criterion> operandA;
-	std::tr1::shared_ptr<criterion> operandB;
+	std::shared_ptr<criterion> operandA;
+	std::shared_ptr<criterion> operandB;
 	std::wstring debugTreeInternal(const std::wstring& curOp) const;
 public:
 	virtual void reorderTree();
 	unsigned __int32 getPriorityClass() const;
-	operation(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b);
+	operation(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b);
 	void makeNonRecursive();
 };
 
 public:
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory) const;
-	andAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b);
+	andAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b);
 	std::wstring debugTree() const;
 };
 class orAndClass : public operation
 public:
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory) const;
-	orAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b);
+	orAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b);
 	std::wstring debugTree() const;
 };
 class xorAndClass : public operation
 public:
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory) const;
-	xorAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b);
+	xorAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b);
 	std::wstring debugTree() const;
 };
 class notAndClass : public criterion
 {
-	std::tr1::shared_ptr<criterion> operand;
+	std::shared_ptr<criterion> operand;
 public:
 	virtual void reorderTree();
 	unsigned __int32 getPriorityClass() const;
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory) const;
-	notAndClass(std::tr1::shared_ptr<criterion> a);
+	notAndClass(std::shared_ptr<criterion> a);
 	std::wstring debugTree() const;
 	void makeNonRecursive();
 };
 class bracketClass : public criterion
 {
-	std::vector<std::tr1::shared_ptr<criterion> > expr;
+	std::vector<std::shared_ptr<criterion> > expr;
 public:
 	virtual void reorderTree();
 	unsigned __int32 getPriorityClass() const;
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory);
-	bracketClass(std::vector<std::tr1::shared_ptr<criterion> > exprA);
+	bracketClass(std::vector<std::shared_ptr<criterion> > exprA);
 	std::wstring debugTree() const;
 	void makeNonRecursive();
 };
 
 class ifClass : public criterion
 {
-	std::tr1::shared_ptr<criterion> condVal;
-	std::tr1::shared_ptr<criterion> tVal;
-	std::tr1::shared_ptr<criterion> fVal;
+	std::shared_ptr<criterion> condVal;
+	std::shared_ptr<criterion> tVal;
+	std::shared_ptr<criterion> fVal;
 public:
 	virtual void reorderTree();
 	unsigned __int32 getPriorityClass() const;
 	BOOL include(FileData &file) const;
 	virtual unsigned int directoryCheck(const std::wstring& directory) const;
-	ifClass(std::tr1::shared_ptr<criterion> condition,std::tr1::shared_ptr<criterion> valueIfTrue,std::tr1::shared_ptr<criterion> valueIfFalse = std::tr1::shared_ptr<criterion>((criterion *)NULL));
+	ifClass(std::shared_ptr<criterion> condition,std::shared_ptr<criterion> valueIfTrue,std::shared_ptr<criterion> valueIfFalse = std::shared_ptr<criterion>((criterion *)NULL));
 	std::wstring debugTree() const;
 	void makeNonRecursive();
 };

pevLib/Version.hpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 //
 #pragma once
 
-#define PEVFIND_VERSION "1.5.11"
+#define PEVFIND_VERSION "1.5.12"

pevLib/clsidCompressor.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/clsidCompressor.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/consoleParser.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #include "FILTER.h"
 
 //Entry point into the parser system
-std::tr1::shared_ptr<criterion> consoleParser::parseCmdLine(const std::wstring& commandLine)
+std::shared_ptr<criterion> consoleParser::parseCmdLine(const std::wstring& commandLine)
 {
     tokenize(commandLine);
     curToken++; //Skip past the program directory itself
     if (boost::algorithm::iequals(curToken->argument, L"vfind"))
         curToken++;
-    std::tr1::shared_ptr<criterion> result(andParse());
+    std::shared_ptr<criterion> result(andParse());
     if (curToken->type != END)
         throw std::runtime_error("Commandline Syntax Error!!");
     return result;
         return MODIFIER;
     return REGEX;
 }
-std::tr1::shared_ptr<criterion> consoleParser::andParse()
+std::shared_ptr<criterion> consoleParser::andParse()
 {
-    std::tr1::shared_ptr<criterion> prev(orParse());
+    std::shared_ptr<criterion> prev(orParse());
     while (curToken->type == AND)
     {
         curToken++;
-        std::tr1::shared_ptr<criterion> cur(orParse());
-        std::tr1::shared_ptr<criterion> newNode(new andAndClass(cur, prev));
+        std::shared_ptr<criterion> cur(orParse());
+        std::shared_ptr<criterion> newNode(new andAndClass(cur, prev));
         prev = newNode;
     }
     return prev;
 }
-std::tr1::shared_ptr<criterion> consoleParser::orParse()
+std::shared_ptr<criterion> consoleParser::orParse()
 {
-    std::tr1::shared_ptr<criterion> prev(xorParse());
+    std::shared_ptr<criterion> prev(xorParse());
     while (curToken->type == OR)
     {
         curToken++;
-        std::tr1::shared_ptr<criterion> cur(xorParse());
-        std::tr1::shared_ptr<criterion> newNode(new orAndClass(cur, prev));
+        std::shared_ptr<criterion> cur(xorParse());
+        std::shared_ptr<criterion> newNode(new orAndClass(cur, prev));
         prev = newNode;
     }
     return prev;
 }
-std::tr1::shared_ptr<criterion> consoleParser::xorParse()
+std::shared_ptr<criterion> consoleParser::xorParse()
 {
-    std::tr1::shared_ptr<criterion> prev(exprParse());
+    std::shared_ptr<criterion> prev(exprParse());
     while (curToken->type == XOR)
     {
         curToken++;
-        std::tr1::shared_ptr<criterion> cur(exprParse());
-        std::tr1::shared_ptr<criterion> newNode(new xorAndClass(cur, prev));
+        std::shared_ptr<criterion> cur(exprParse());
+        std::shared_ptr<criterion> newNode(new xorAndClass(cur, prev));
         prev = newNode;
     }
     return prev;
 }
-std::tr1::shared_ptr<criterion> consoleParser::exprParse()
+std::shared_ptr<criterion> consoleParser::exprParse()
 {
-    std::vector<std::tr1::shared_ptr<criterion> > results;
+    std::vector<std::shared_ptr<criterion> > results;
     while (isExpressionArgumentType())
     {
         switch(curToken->type)
         case NOT:
             {
                 curToken++;
-                std::tr1::shared_ptr<criterion> ptrVal(new notAndClass(exprParse()));
+                std::shared_ptr<criterion> ptrVal(new notAndClass(exprParse()));
                 results.push_back(ptrVal);
             }
             break;
             break;
         case REGEX:
             {
-                std::tr1::shared_ptr<regexClass> ptrVal(new vFindRegex(curToken->argument));
+                std::shared_ptr<regexClass> ptrVal(new vFindRegex(curToken->argument));
                 results.push_back(ptrVal);
                 globalOptions::regularExpressions.push_back(ptrVal);
                 curToken++;
     case 1:
         return results[0];
     default:
-        return std::tr1::shared_ptr<criterion>( new bracketClass(results) );
+        return std::shared_ptr<criterion>( new bracketClass(results) );
     }
 }
-std::tr1::shared_ptr<criterion> consoleParser::createBracket()
+std::shared_ptr<criterion> consoleParser::createBracket()
 {
     curToken++;
-    std::tr1::shared_ptr<criterion> result = andParse();
+    std::shared_ptr<criterion> result = andParse();
     if (curToken->type != ENDBRACKET)
         throw std::runtime_error("Unbalanced {}s in your expression.");
     return result;
 }
-std::tr1::shared_ptr<criterion> consoleParser::createIf()
+std::shared_ptr<criterion> consoleParser::createIf()
 {
     curToken++;
-    std::tr1::shared_ptr<criterion> condition(exprParse());
-    std::tr1::shared_ptr<criterion> then(exprParse());
-    std::tr1::shared_ptr<criterion> els((criterion *)NULL);
+    std::shared_ptr<criterion> condition(exprParse());
+    std::shared_ptr<criterion> then(exprParse());
+    std::shared_ptr<criterion> els((criterion *)NULL);
     if (curToken->type == ELSEARG)
     {
         curToken++;
         els = exprParse();
     }
-    std::tr1::shared_ptr<criterion> result(new ifClass(condition, then, els));
+    std::shared_ptr<criterion> result(new ifClass(condition, then, els));
     return result;
 }
 bool consoleParser::isExpressionArgumentType()
     }
     return false;
 }
-void consoleParser::createModifier(std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::createModifier(std::vector<std::shared_ptr<criterion> > &results)
 {
     using namespace boost::algorithm;
     commandToken token = *curToken;
         }
         else if (istarts_with(token.argument, L"files"))
         {
-            std::tr1::shared_ptr<regexClass> it(new filesRegexPlaceHolder());
+            std::shared_ptr<regexClass> it(new filesRegexPlaceHolder());
             results.push_back(it);
             globalOptions::regularExpressions.push_back(it);
             processFilesArgument(token);
         {
             token.argument.clear();
             boost::algorithm::replace_all(token.option, L"##", L"#");
-            std::tr1::shared_ptr<regexClass> ptrVal(new vFindRegex(token.option, false));
+            std::shared_ptr<regexClass> ptrVal(new vFindRegex(token.option, false));
             results.push_back(ptrVal);
             globalOptions::regularExpressions.push_back(ptrVal);
         }
         {
             token.argument.clear();
             boost::algorithm::replace_all(token.option, L"##", L"#");
-            results.push_back(std::tr1::shared_ptr<regexClass>(new perlRegex(token.option)));
+            results.push_back(std::shared_ptr<regexClass>(new perlRegex(token.option)));
         }
         else if (istarts_with(token.argument, L"r"))
         {
         else if (istarts_with(token.argument, L"skip"))
         {
             removeArgument(4, token.argument);
-            results.push_back(std::tr1::shared_ptr<criterion>(new skipper(getEndOrOption(token))));
+            results.push_back(std::shared_ptr<criterion>(new skipper(getEndOrOption(token))));
             token.argument.clear();
         }
         else if (istarts_with(token.argument, L"s"))
     while(it != arg.end() && *it == L':') { it++; };
     arg.erase(arg.begin(), it);
 }
-void consoleParser::parseTypeString(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::parseTypeString(commandToken& token, std::vector<std::shared_ptr<criterion> > &results)
 {
     std::wstring::iterator it = token.argument.begin();
     bool foundType = true;
         {
         case L'A':
         case L'a':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isArchive()));
+            results.push_back(std::shared_ptr<criterion>(new isArchive()));
             break;
         case L'B':
         case L'b':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isPEPlusFile()));
+            results.push_back(std::shared_ptr<criterion>(new isPEPlusFile()));
             break;
         case L'C':
         case L'c':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isCompressed()));
+            results.push_back(std::shared_ptr<criterion>(new isCompressed()));
             break;
         case L'D':
         case L'd':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isDirectory()));
+            results.push_back(std::shared_ptr<criterion>(new isDirectory()));
             break;
         case L'E':
         case L'e':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isReparsePoint()));
+            results.push_back(std::shared_ptr<criterion>(new isReparsePoint()));
             break;
         case L'F':
         case L'f':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isFile()));
+            results.push_back(std::shared_ptr<criterion>(new isFile()));
             break;
         case L'G':
         case L'g':
-            results.push_back(std::tr1::shared_ptr<criterion>(new sigIsValid()));
+            results.push_back(std::shared_ptr<criterion>(new sigIsValid()));
             break;
         case L'I':
         case L'i':
-            results.push_back(std::tr1::shared_ptr<criterion>(new hasSig()));
+            results.push_back(std::shared_ptr<criterion>(new hasSig()));
             break;
         case L'J':
         case L'j':
-            results.push_back(std::tr1::shared_ptr<criterion>(new timestampValid()));
+            results.push_back(std::shared_ptr<criterion>(new timestampValid()));
             break;
         case L'K':
         case L'k':
-            results.push_back(std::tr1::shared_ptr<criterion>(new checkSumValid()));
+            results.push_back(std::shared_ptr<criterion>(new checkSumValid()));
             break;
         case L'L':
         case L'l':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isDLLFile()));
+            results.push_back(std::shared_ptr<criterion>(new isDLLFile()));
             break;
         case L'O':
         case L'o':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isSFCProtected()));
+            results.push_back(std::shared_ptr<criterion>(new isSFCProtected()));
             break;
         case L'P':
         case L'p':
             if (boost::istarts_with(boost::iterator_range<std::wstring::iterator>(it, token.argument.end()), L"pne"))
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new isNEFile()));
+                results.push_back(std::shared_ptr<criterion>(new isNEFile()));
                 it += 2;
             } else if (boost::istarts_with(boost::iterator_range<std::wstring::iterator>(it, token.argument.end()), L"ple"))
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new isLEFile()));
+                results.push_back(std::shared_ptr<criterion>(new isLEFile()));
                 it += 2;
             } else if (boost::istarts_with(boost::iterator_range<std::wstring::iterator>(it, token.argument.end()), L"pmz"))
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new isMZFile()));
+                results.push_back(std::shared_ptr<criterion>(new isMZFile()));
                 it += 2;
             } else if (boost::istarts_with(boost::iterator_range<std::wstring::iterator>(it, token.argument.end()), L"p2"))
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new is2ExecFile()));
+                results.push_back(std::shared_ptr<criterion>(new is2ExecFile()));
                 it++;
             } else if (boost::istarts_with(boost::iterator_range<std::wstring::iterator>(it, token.argument.end()), L"p64"))
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new isPEPlusFile()));
+                results.push_back(std::shared_ptr<criterion>(new isPEPlusFile()));
                 it += 2;
             } else
             {
-                results.push_back(std::tr1::shared_ptr<criterion>(new isPEFile()));
+                results.push_back(std::shared_ptr<criterion>(new isPEFile()));
             }
             break;
         case L'H':
         case L'h':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isHidden()));
+            results.push_back(std::shared_ptr<criterion>(new isHidden()));
             break;
         case L'R':
         case L'r':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isReadOnly()));
+            results.push_back(std::shared_ptr<criterion>(new isReadOnly()));
             break;
         case L'S':
         case L's':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isSystem()));
+            results.push_back(std::shared_ptr<criterion>(new isSystem()));
             break;
         case L'V':
         case L'v':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isVolumeLabel()));
+            results.push_back(std::shared_ptr<criterion>(new isVolumeLabel()));
             break;
         case L'W':
         case L'w':
-            results.push_back(std::tr1::shared_ptr<criterion>(new isWritable()));
+            results.push_back(std::shared_ptr<criterion>(new isWritable()));
             break;
         default:
             foundType = false;
     token.argument.erase(token.argument.begin(), it);
 }
 
-void consoleParser::createDate(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::createDate(commandToken& token, std::vector<std::shared_ptr<criterion> > &results)
 {
     removeArgument(1, token.argument);
     switch (token.argument[0])
         throw std::runtime_error("Invalid sort!");
 }
 
-void consoleParser::parseNotTypeString(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::parseNotTypeString(commandToken& token, std::vector<std::shared_ptr<criterion> > &results)
 {
-    std::vector<std::tr1::shared_ptr<criterion> > resTmp;
+    std::vector<std::shared_ptr<criterion> > resTmp;
     parseTypeString(token, resTmp);
     if (resTmp.size())
     {
-        for (std::vector<std::tr1::shared_ptr<criterion> >::iterator it = resTmp.begin(); it != resTmp.end(); it++)
-            results.push_back( std::tr1::shared_ptr<criterion>(new notAndClass(*it)) );
+        for (std::vector<std::shared_ptr<criterion> >::iterator it = resTmp.begin(); it != resTmp.end(); it++)
+            results.push_back( std::shared_ptr<criterion>(new notAndClass(*it)) );
     }
     
 }
-void consoleParser::createSize(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::createSize(commandToken& token, std::vector<std::shared_ptr<criterion> > &results)
 {
     removeArgument(1, token.argument);
     wchar_t typeChar = token.argument[0];
     if (      typeChar == L'+' || typeChar == L'G' || typeChar == L'g' )
     {
         removeArgument(1, token.argument);
-        results.push_back(std::tr1::shared_ptr<criterion>( new gtSizeFilter(processUL(token))));
+        results.push_back(std::shared_ptr<criterion>( new gtSizeFilter(processUL(token))));
     } else if ( typeChar == L'-' || typeChar == L'L' || typeChar == L'l' )
     {
         removeArgument(1, token.argument);
-        results.push_back(std::tr1::shared_ptr<criterion>( new ltSizeFilter(processUL(token))));
+        results.push_back(std::shared_ptr<criterion>( new ltSizeFilter(processUL(token))));
     } else if ( typeChar == L'=' )
     {
         removeArgument(1, token.argument);
-        results.push_back(std::tr1::shared_ptr<criterion>( new isSizeFilter(processUL(token))));
+        results.push_back(std::shared_ptr<criterion>( new isSizeFilter(processUL(token))));
     } else if ( typeChar == L'!' )
     {
         removeArgument(1, token.argument);
-        results.push_back(std::tr1::shared_ptr<criterion>( new notSizeFilter(processUL(token))));
+        results.push_back(std::shared_ptr<criterion>( new notSizeFilter(processUL(token))));
     } else //Number range
     {
         __int64 a = processUL(token);
         __int64 b = processUL(token);
         if (a > b)
             std::swap(a, b);
-        results.push_back(std::tr1::shared_ptr<criterion>( new gtSizeFilter(a - 1)));
-        results.push_back(std::tr1::shared_ptr<criterion>( new ltSizeFilter(b + 1)));
+        results.push_back(std::shared_ptr<criterion>( new gtSizeFilter(a - 1)));
+        results.push_back(std::shared_ptr<criterion>( new ltSizeFilter(b + 1)));
     }
 }

pevLib/consoleParser.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
     tokenType makeTypeFromToken(const std::wstring& argument);
 
     //Recursive-Descent Parser
-    std::tr1::shared_ptr<criterion> andParse();
-    std::tr1::shared_ptr<criterion> orParse();
-    std::tr1::shared_ptr<criterion> xorParse();
-    std::tr1::shared_ptr<criterion> exprParse();
+    std::shared_ptr<criterion> andParse();
+    std::shared_ptr<criterion> orParse();
+    std::shared_ptr<criterion> xorParse();
+    std::shared_ptr<criterion> exprParse();
 
     //Helpers for the R-D Parser
     bool isExpressionArgumentType();
-    std::tr1::shared_ptr<criterion> createBracket();
-    std::tr1::shared_ptr<criterion> createIf();
-    void createModifier(std::vector<std::tr1::shared_ptr<criterion> > &results);
+    std::shared_ptr<criterion> createBracket();
+    std::shared_ptr<criterion> createIf();
+    void createModifier(std::vector<std::shared_ptr<criterion> > &results);
     void removeArgument(std::size_t argLength, std::wstring& arg);
     void processFilesArgument(commandToken& token);
     void processLoadlineArgument(commandToken& token);
     long processLong(commandToken& token);
     long processLong(std::wstring& numberString);
     std::wstring& getEndOrOption(commandToken& token) const;
-    template <typename hash_t> std::tr1::shared_ptr<criterion> createHashList(commandToken& token, std::size_t hashNameLen);
-    template <typename hash_t> std::tr1::shared_ptr<criterion> createHash(commandToken& token, std::size_t hashNameLen);
+    template <typename hash_t> std::shared_ptr<criterion> createHashList(commandToken& token, std::size_t hashNameLen);
+    template <typename hash_t> std::shared_ptr<criterion> createHash(commandToken& token, std::size_t hashNameLen);
     void ascendingSorts(commandToken& token);
     void descendingSorts(commandToken& token);
-    void parseTypeString(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results);
-    void parseNotTypeString(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results);
-    void createSize(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results);
-    void createDate(commandToken& token, std::vector<std::tr1::shared_ptr<criterion> > &results);
+    void parseTypeString(commandToken& token, std::vector<std::shared_ptr<criterion> > &results);
+    void parseNotTypeString(commandToken& token, std::vector<std::shared_ptr<criterion> > &results);
+    void createSize(commandToken& token, std::vector<std::shared_ptr<criterion> > &results);
+    void createDate(commandToken& token, std::vector<std::shared_ptr<criterion> > &results);
     void parseTypeString(TCHAR const *typeString, std::vector<criterion *>& results);
     
     void processAbsoluteDate( std::wstring& toProcess, FILETIME& lowerBound, FILETIME& upperBound);
     template <typename lowerClass, typename upperClass> 
-        void subDateType(std::wstring& token, std::vector<std::tr1::shared_ptr<criterion> > &results);
+        void subDateType(std::wstring& token, std::vector<std::shared_ptr<criterion> > &results);
     void processRelativeDate(std::wstring& token, FILETIME &result);
     std::vector<std::wstring> stripCommandStruct(std::vector<commandToken>::iterator start, std::vector<commandToken>::iterator end);
 public:
-    std::tr1::shared_ptr<criterion> parseCmdLine(const std::wstring& commandLine);
+    std::shared_ptr<criterion> parseCmdLine(const std::wstring& commandLine);
 };
 
 
-template <typename hash_t> std::tr1::shared_ptr<criterion> consoleParser::createHashList(commandToken& token, std::size_t hashNameLen)
+template <typename hash_t> std::shared_ptr<criterion> consoleParser::createHashList(commandToken& token, std::size_t hashNameLen)
 {
     removeArgument(hashNameLen, token.argument);
-    std::tr1::shared_ptr<criterion> crit(new hash_t(loadStringsFromFile(getEndOrOption(token))));
+    std::shared_ptr<criterion> crit(new hash_t(loadStringsFromFile(getEndOrOption(token))));
     token.argument.clear();
     return crit;
 }
 
-template <typename hash_t> std::tr1::shared_ptr<criterion> consoleParser::createHash(commandToken& token, std::size_t hashNameLen)
+template <typename hash_t> std::shared_ptr<criterion> consoleParser::createHash(commandToken& token, std::size_t hashNameLen)
 {
     removeArgument(hashNameLen, token.argument);
-    std::tr1::shared_ptr<criterion> result(new hash_t(getEndOrOption(token)));
+    std::shared_ptr<criterion> result(new hash_t(getEndOrOption(token)));
     token.argument.clear();
     return result;
 }
 
 template <typename lowerClass, typename upperClass> 
-void consoleParser::subDateType(std::wstring& token, std::vector<std::tr1::shared_ptr<criterion> > &results)
+void consoleParser::subDateType(std::wstring& token, std::vector<std::shared_ptr<criterion> > &results)
 {
     FILETIME lowerBound, upperBound;
     wchar_t type = token[0];
         // Absolute date arguments
     case L'+':
         processAbsoluteDate(token, lowerBound, upperBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new upperClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new upperClass(lowerBound)));
         break;
     case L'-':
         processAbsoluteDate(token, lowerBound, upperBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new lowerClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new lowerClass(lowerBound)));
         break;
     case L'=':
         processAbsoluteDate(token, lowerBound, upperBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new upperClass(lowerBound)));
-        results.push_back(std::tr1::shared_ptr<criterion>(new lowerClass(upperBound)));
+        results.push_back(std::shared_ptr<criterion>(new upperClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new lowerClass(upperBound)));
         break;
     case L'!':
         processAbsoluteDate(token, lowerBound, upperBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new lowerClass(upperBound)));
-        results.push_back(std::tr1::shared_ptr<criterion>(new upperClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new lowerClass(upperBound)));
+        results.push_back(std::shared_ptr<criterion>(new upperClass(lowerBound)));
         break;
         // Relative date arguments
     case L'G':
     case L'g':
         processRelativeDate(token, lowerBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new upperClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new upperClass(lowerBound)));
         break;
     case L'L':
     case L'l':
         processRelativeDate(token, lowerBound);
-        results.push_back(std::tr1::shared_ptr<criterion>(new lowerClass(lowerBound)));
+        results.push_back(std::shared_ptr<criterion>(new lowerClass(lowerBound)));
         break;
     default:
         throw std::runtime_error("Invalid date argument!");

pevLib/criterion.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 //Functor which converts pointers to criteria to priority classes
 static struct _getPriorityFunctor : std::unary_function<const criterion*, __int32>
 {
-	__int32 operator()(const std::tr1::shared_ptr<criterion> crit)
+	__int32 operator()(const std::shared_ptr<criterion> crit)
 	{
 		return crit->getPriorityClass();
 	};
 } getPriorityFunctor;
 
-static struct _criterionByPriorityClass : std::binary_function<const std::tr1::shared_ptr<criterion>, std::tr1::shared_ptr<criterion>, bool>
+static struct _criterionByPriorityClass : std::binary_function<const std::shared_ptr<criterion>, std::shared_ptr<criterion>, bool>
 {
-	bool operator()(const std::tr1::shared_ptr<criterion> a, const std::tr1::shared_ptr<criterion> b)
+	bool operator()(const std::shared_ptr<criterion> a, const std::shared_ptr<criterion> b)
 	{
 		return a->getPriorityClass() < b->getPriorityClass();
 	}

pevLib/dosdev.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _DOSDEV_H_INCLUDED
 #define _DOSDEV_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/fileData.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 		return;
 
 	//Get a handle to the file
-	std::tr1::shared_ptr<void> hFile(getFileHandle(), CloseHandle);
+	std::shared_ptr<void> hFile(getFileHandle(), CloseHandle);
 	//Report false if the file could not be obtained
 	if (hFile.get() == INVALID_HANDLE_VALUE)
 		return;
 	//Load the SFCFiles.dll module.
 	wchar_t buffer[MAX_PATH];
 	ExpandEnvironmentStrings(L"%WINDIR%\\System32\\sfcfiles.dll", buffer, MAX_PATH);
-	std::tr1::shared_ptr<void> sfcFiles(LoadLibrary(buffer), FreeLibrary);
+	std::shared_ptr<void> sfcFiles(LoadLibrary(buffer), FreeLibrary);
 	if (!(sfcFiles.get()))
 	{
 		sfcState = NO_SFCFILES_DLL;
 	if (isPE() && peHeaderChecksumIsValid() && getPEHeaderCheckSum() != 0) return;
 
 	//Get a handle to the file
-	std::tr1::shared_ptr<void> hFile(getFileHandle(false), CloseHandle);
+	std::shared_ptr<void> hFile(getFileHandle(false), CloseHandle);
 	//Report false if the file could not be obtained
 	if (hFile.get() == INVALID_HANDLE_VALUE)
 		return;

pevLib/fileData.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 	mutable std::vector<LANGANDCODEPAGE> versionTranslations;
 
 	//Hex management 
-	std::tr1::shared_ptr<std::vector<std::pair<unsigned int, bool> > > hexStorage;
+	std::shared_ptr<std::vector<std::pair<unsigned int, bool> > > hexStorage;
 
 	//Enumeration functions
 	//When the results aren't cached in the bitset bits, these functions calculate

pevLib/filesScanner.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/filesScanner.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/globalOptions.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #include "globalOptions.h"
 #include "regex.h"
 
-std::vector<std::tr1::shared_ptr<regexClass> > globalOptions::regularExpressions;
-std::tr1::shared_ptr<criterion>  globalOptions::logicalTree;
+std::vector<std::shared_ptr<regexClass> > globalOptions::regularExpressions;
+std::shared_ptr<criterion>  globalOptions::logicalTree;
 bool globalOptions::debug = false;
 bool globalOptions::fullPath = false;
 bool globalOptions::summary = false;

pevLib/globalOptions.h

 #ifndef _GLOBAL_OPTIONS_H_INCLUDED
 #define _GLOBAL_OPTIONS_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 // components.
 #include <string>
 #include <vector>
+#include <memory>
 
 class regexClass;
 class criterion;
 class globalOptions
 {
 public:
-	static std::vector<std::tr1::shared_ptr<regexClass> > regularExpressions;
-	static std::tr1::shared_ptr<criterion> logicalTree;
+	static std::vector<std::shared_ptr<regexClass> > regularExpressions;
+	static std::shared_ptr<criterion> logicalTree;
 	static bool debug;
 	static bool fullPath;
 	static bool summary;
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/linkResolve.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/linkResolve.h

 #ifndef _LINK_RESOLVE_H_INCLUDED
 #define _LINK_RESOLVE_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/logger.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _LOGGER_H_INCLUDED
 #define _LOGGER_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/mainScanner.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 		std::list<std::wstring> foldersToScan;
 		if (globalOptions::noSubDirectories)
 		{
-			for (std::vector<std::tr1::shared_ptr<regexClass> >::iterator it = globalOptions::regularExpressions.begin(); it != globalOptions::regularExpressions.end(); it++)
+			for (std::vector<std::shared_ptr<regexClass> >::iterator it = globalOptions::regularExpressions.begin(); it != globalOptions::regularExpressions.end(); it++)
 			{
 				std::wstring curRegexRoot((*it)->getPathRoot());
 				if ((*it)->getPathRoot().empty())
 		printSummary();
 	}
 
-	std::wstring getRegexesCommonRoot(std::vector<std::tr1::shared_ptr<regexClass> >& targets)
+	std::wstring getRegexesCommonRoot(std::vector<std::shared_ptr<regexClass> >& targets)
 	{
 		//Sanity check:
 		if (!targets.size()) return L"";
 		std::vector<std::wstring> candidates;
 		candidates.reserve(targets.size());
 		//Keep the roots of the regexes in the running if they are not empty.
-		for(std::vector<std::tr1::shared_ptr<regexClass> >::const_iterator it = targets.begin(); it != targets.end(); it++)
+		for(std::vector<std::shared_ptr<regexClass> >::const_iterator it = targets.begin(); it != targets.end(); it++)
 		{
 			if (! (**it).getPathRoot().empty() ) candidates.push_back((**it).getPathRoot());
 		}

pevLib/mainScanner.h

 #ifndef _MAINSCANNER_H_FILE_INCLUDED
 #define _MAINSCANNER_H_FILE_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
 namespace scanners
 {
-	std::wstring getRegexesCommonRoot(std::vector<std::tr1::shared_ptr<regexClass> >&);
+	std::wstring getRegexesCommonRoot(std::vector<std::shared_ptr<regexClass> >&);
 	void printSummary();
 	class recursiveScanner
 	{	

pevLib/moveex.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _MOVE_EX_H_INCLUDED
 #define _MOVE_EX_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/opstruct.cpp

 	return classB;
 
 };
-operation::operation(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b) : operandA(a), operandB(b)
+operation::operation(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b) : operandA(a), operandB(b)
 {}
 BOOL andAndClass::include(FileData &file) const
 {
 		return resA;
 	return resA && resB;
 }
-andAndClass::andAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b) : operation(a, b)
+andAndClass::andAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b) : operation(a, b)
 {}
 std::wstring andAndClass::debugTree() const
 {
 		return resA;
 	return resA || resB;
 }
-orAndClass::orAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b) : operation(a, b)
+orAndClass::orAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b) : operation(a, b)
 {}
 std::wstring orAndClass::debugTree() const
 {
 		return resA;
 	return (resA || resB) && !(resA && resB);
 }
-xorAndClass::xorAndClass(std::tr1::shared_ptr<criterion> a, std::tr1::shared_ptr<criterion> b) : operation(a, b)
+xorAndClass::xorAndClass(std::shared_ptr<criterion> a, std::shared_ptr<criterion> b) : operation(a, b)
 {}
 std::wstring xorAndClass::debugTree() const
 {
 	}
 	return DIRECTORY_DONTCARE;
 }
-notAndClass::notAndClass(std::tr1::shared_ptr<criterion> a) : operand(a)
+notAndClass::notAndClass(std::shared_ptr<criterion> a) : operand(a)
 {}
 std::wstring notAndClass::debugTree() const
 {
 	else
 		return DIRECTORY_INCLUDE;
 }
-bracketClass::bracketClass(std::vector<std::tr1::shared_ptr<criterion> > exprA): expr(exprA)
+bracketClass::bracketClass(std::vector<std::shared_ptr<criterion> > exprA): expr(exprA)
 { 
 	assert(expr.size() > 1);
 }
 std::wstring bracketClass::debugTree() const
 {
 	std::wstring dbgMsg(L"- BRACKET\r\n");
-	for (std::vector<std::tr1::shared_ptr<criterion> >::const_iterator it = expr.begin(); it != expr.end(); it++)
+	for (std::vector<std::shared_ptr<criterion> >::const_iterator it = expr.begin(); it != expr.end(); it++)
 	{
 		dbgMsg.append((*it)->debugTree());
 		if (it + 1 != expr.end())
 		return fVal->directoryCheck(directory);
 	}
 }
-ifClass::ifClass(std::tr1::shared_ptr<criterion> condition,std::tr1::shared_ptr<criterion> valueIfTrue,std::tr1::shared_ptr<criterion> valueIfFalse)
+ifClass::ifClass(std::shared_ptr<criterion> condition,std::shared_ptr<criterion> valueIfTrue,std::shared_ptr<criterion> valueIfFalse)
 	: condVal(condition), tVal(valueIfTrue), fVal(valueIfFalse)
 {}
 std::wstring ifClass::debugTree() const
 
 void bracketClass::makeNonRecursive()
 {
-	for (std::vector<std::tr1::shared_ptr<criterion> >::iterator it = expr.begin(); it != expr.end(); it++)
+	for (std::vector<std::shared_ptr<criterion> >::iterator it = expr.begin(); it != expr.end(); it++)
 	{
 		(*it)->makeNonRecursive();
 	}

pevLib/pevLib.vcxproj

     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
-    <PlatformToolset>v100</PlatformToolset>
+    <PlatformToolset>v110</PlatformToolset>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
       <RuntimeTypeInfo>false</RuntimeTypeInfo>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <PrecompiledHeaderFile>pch.hpp</PrecompiledHeaderFile>
     </ClCompile>
   </ItemDefinitionGroup>

pevLib/procListers.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/procListers.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/procManager.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/processManager.h

 #ifndef _PROC_MANAGER_H_INCLUDED
 #define _PROC_MANAGER_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 	OUT PTOKEN_PRIVILEGES OPTIONAL,
 	OUT PULONG OPTIONAL ); 
 
-typedef enum _PROCESS_INFORMATION_CLASS {
+typedef enum _PROCESS_INFORMATION_CLASS_PEV {
 	ProcessBasicInformation,
 	ProcessQuotaLimits,
 	ProcessIoCounters,
 	ProcessAffinityMask,
 	ProcessPriorityBoost,
 	MaxProcessInfoClass
-} PROCESS_INFORMATION_CLASS, *PPROCESS_INFORMATION_CLASS;
+} PROCESS_INFORMATION_CLASS_PEV, *PPROCESS_INFORMATION_CLASS_PEV;
 
 
 typedef NTSTATUS (NTAPI *_NtQueryInformationProcess)(
 	IN HANDLE,
-	IN PROCESS_INFORMATION_CLASS,
+	IN PROCESS_INFORMATION_CLASS_PEV,
 	OUT PVOID,
 	IN ULONG,
 	OUT PULONG); 

pevLib/processScanner.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/processScanner.h

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/regImport.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/regImport.h

 #ifndef _REG_IMPORT_H_INCLUDED
 #define _REG_IMPORT_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _REGEX_H_INCLUDED
 #define _REGEX_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/registry.h

 #ifndef _REGISTRY_H_INCLUDED
 #define _REGISTRY_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/reportAssembler.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/reportAssembler.hpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/reportComponents.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/reportComponents.hpp

-//              Copyright Billy O'Neal 2011
+//              Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/rexport.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _REXPORT_H_INCLUDED
 #define _REXPORT_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/serviceControl.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/serviceControl.h

 #ifndef _SERVICE_CONTROL_H_INCLUDED
 #define _SERVICE_CONTROL_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/stlUtil.hpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/timeoutThread.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/timeoutThread.h

 #ifndef _TIMEOUT_THREAD_H_INCLUDED
 #define _TIMEOUT_THREAD_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _TIMES_H_INCLUDED
 #define _TIMES_H_INCLUDED
 
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _UZIP_H_INCLUDED
 #define _UZIP_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/utility.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 #ifndef _UTILITY_H_INCLUDED
 #define _UTILITY_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/volumeEnumerate.cpp

-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)

pevLib/volumeEnumerate.h

 #ifndef _VOLUME_ENUMERATE_H_INCLUDED
 #define _VOLUME_ENUMERATE_H_INCLUDED
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
-//          Copyright Billy O'Neal 2011
+//          Copyright Billy O'Neal 2012
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.