Make QPDFArgParser accept const argv

This makes it much more convention to use the initializeFromArgv
functions since you can use string literals.

3 files changed, 40 insertions, 16 deletions

diff --git a/libtests/arg_parser.cc b/libtests/arg_parser.cc
index e17ebdd1..0c7e6787 100644
--- a/libtests/arg_parser.cc
+++ b/libtests/arg_parser.cc
@@ -15,12 +15,12 @@ class ArgParser
 
   private:
     void handlePotato();
-    void handleSalad(char* p);
-    void handleMoo(char* p);
-    void handleOink(char* p);
-    void handleQuack(char* p);
+    void handleSalad(std::string const& p);
+    void handleMoo(std::string const& p);
+    void handleOink(std::string const& p);
+    void handleQuack(std::string const& p);
     void startQuack();
-    void getQuack(char* p);
+    void getQuack(std::string const& p);
     void endQuack();
     void finalChecks();
 
@@ -44,7 +44,7 @@ ArgParser::initOptions()
     auto b = [this](void (ArgParser::*f)()) {
         return QPDFArgParser::bindBare(f, this);
     };
-    auto p = [this](void (ArgParser::*f)(char *)) {
+    auto p = [this](void (ArgParser::*f)(std::string const&)) {
         return QPDFArgParser::bindParam(f, this);
     };
 
@@ -98,19 +98,19 @@ ArgParser::handlePotato()
 }
 
 void
-ArgParser::handleSalad(char* p)
+ArgParser::handleSalad(std::string const& p)
 {
     output(std::string("got salad=") + p);
 }
 
 void
-ArgParser::handleMoo(char* p)
+ArgParser::handleMoo(std::string const& p)
 {
-    output(std::string("got moo=") + (p ? p : "(none)"));
+    output(std::string("got moo=") + (p.empty() ? "(none)" : p));
 }
 
 void
-ArgParser::handleOink(char* p)
+ArgParser::handleOink(std::string const& p)
 {
     output(std::string("got oink=") + p);
 }
@@ -137,7 +137,7 @@ ArgParser::startQuack()
 }
 
 void
-ArgParser::getQuack(char* p)
+ArgParser::getQuack(std::string const& p)
 {
     ++this->quacks;
     if (this->ap.isCompleting() && (this->ap.argsLeft() == 0))
@@ -210,7 +210,7 @@ ArgParser::test_exceptions()
     });
     err("invalid choice handler to unknown", [this]() {
         ap.addInvalidChoiceHandler(
-            "elephant", [](char*){});
+            "elephant", [](std::string const&){});
     });
 }
 
diff --git a/libtests/main_from_wmain.cc b/libtests/main_from_wmain.cc
index c3e2a716..6b8a9c05 100644
--- a/libtests/main_from_wmain.cc
+++ b/libtests/main_from_wmain.cc
@@ -4,17 +4,37 @@
 #ifndef QPDF_NO_WCHAR_T
 void wmain_test()
 {
+    // writable args and function args
     auto realmain = [](int argc, char* argv[]) {
-                        for (int i = 0; i < argc; ++i) {
-                            std::cout << argv[i] << std::endl;
-                        } return 0;
-                    };
+        for (int i = 0; i < argc; ++i) {
+            std::cout << argv[i] << std::endl;
+        } return 0;
+    };
     wchar_t* argv[3];
+    // This works because call_main_from_wmain doesn't actually write
+    // to the arguments and neither does our function. Otherwise, this
+    // cast would be unsafe.
     argv[0] = const_cast<wchar_t*>(L"ascii");
     argv[1] = const_cast<wchar_t*>(L"10 \xf7 2 = 5");
     argv[2] = const_cast<wchar_t*>(L"qwww\xf7\x03c0");
     QUtil::call_main_from_wmain(3, argv, realmain);
 }
+
+void cwmain_test()
+{
+    // const args and function args
+    auto realmain = [](int argc, char const* const argv[]) {
+        for (int i = 0; i < argc; ++i) {
+            std::cout << "const " << argv[i] << std::endl;
+        } return 0;
+    };
+    wchar_t const* argv[3] = {
+        L"ascii",
+        L"10 \xf7 2 = 5",
+        L"qwww\xf7\x03c0",
+    };
+    QUtil::call_main_from_wmain(3, argv, realmain);
+}
 #endif // QPDF_NO_WCHAR_T
 
 int main(int argc, char* argv[])
@@ -23,6 +43,7 @@ int main(int argc, char* argv[])
     try
     {
 	wmain_test();
+	cwmain_test();
     }
     catch (std::exception& e)
     {
diff --git a/libtests/qtest/qutil/wmain.out b/libtests/qtest/qutil/wmain.out
index 261b1c56..5a1eb6f3 100644
--- a/libtests/qtest/qutil/wmain.out
+++ b/libtests/qtest/qutil/wmain.out
@@ -1,3 +1,6 @@
 ascii
 10 ÷ 2 = 5
 qwww÷π
+const ascii
+const 10 ÷ 2 = 5
+const qwww÷π