OpenSystemsDevelopment / qpdf

#include <qpdf/QPDFJob.hh>

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <cstdio>
#include <ctype.h>
#include <memory>

#include <qpdf/QUtil.hh>
#include <qpdf/QTC.hh>
#include <qpdf/QPDFCryptoProvider.hh>
#include <qpdf/QPDFArgParser.hh>
#include <qpdf/QPDFJob.hh>
#include <qpdf/QIntC.hh>

namespace
{
    class ArgParser
    {
      public:
        ArgParser(QPDFArgParser& ap, QPDFJob& o);
        void parseOptions();

      private:
        static constexpr char const* O_PAGES = "pages";
        static constexpr char const* O_ENCRYPT = "encryption";
        static constexpr char const* O_ENCRYPT_40 = "40-bit encryption";
        static constexpr char const* O_ENCRYPT_128 = "128-bit encryption";
        static constexpr char const* O_ENCRYPT_256 = "256-bit encryption";
        static constexpr char const* O_UNDER_OVERLAY = "underlay/overlay";
        static constexpr char const* O_ATTACHMENT = "attachment";
        static constexpr char const* O_COPY_ATTACHMENT = "copy attachment";

        void argHelp();
        void argVersion();
        void argCopyright();
        void argJsonHelp();
        void argShowCrypto();
        void argPositional(char* arg);
        void argPassword(char* parameter);
        void argPasswordFile(char* parameter);
        void argEmpty();
        void argLinearize();
        void argEncrypt();
        void argDecrypt();
        void argPasswordIsHexKey();
        void argAllowInsecure();
        void argAllowWeakCrypto();
        void argPasswordMode(char* parameter);
        void argSuppressPasswordRecovery();
        void argCopyEncryption(char* parameter);
        void argEncryptionFilePassword(char* parameter);
        void argPages();
        void argPagesPassword(char* parameter);
        void argPagesPositional(char* parameter);
        void argEndPages();
        void argUnderlay();
        void argOverlay();
        void argRotate(char* parameter);
        void argCollate(char* parameter);
        void argFlattenRotation();
        void argListAttachments();
        void argShowAttachment(char* parameter);
        void argRemoveAttachment(char* parameter);
        void argAddAttachment();
        void argCopyAttachments();
        void argStreamData(char* parameter);
        void argCompressStreams(char* parameter);
        void argRecompressFlate();
        void argCompressionLevel(char* parameter);
        void argDecodeLevel(char* parameter);
        void argNormalizeContent(char* parameter);
        void argSuppressRecovery();
        void argObjectStreams(char* parameter);
        void argIgnoreXrefStreams();
        void argQdf();
        void argPreserveUnreferenced();
        void argPreserveUnreferencedResources();
        void argRemoveUnreferencedResources(char* parameter);
        void argKeepFilesOpen(char* parameter);
        void argKeepFilesOpenThreshold(char* parameter);
        void argNewlineBeforeEndstream();
        void argLinearizePass1(char* parameter);
        void argCoalesceContents();
        void argFlattenAnnotations(char* parameter);
        void argGenerateAppearances();
        void argMinVersion(char* parameter);
        void argForceVersion(char* parameter);
        void argSplitPages(char* parameter);
        void argVerbose();
        void argProgress();
        void argNoWarn();
        void argWarningExitZero();
        void argDeterministicId();
        void argStaticId();
        void argStaticAesIv();
        void argNoOriginalObjectIds();
        void argShowEncryption();
        void argShowEncryptionKey();
        void argCheckLinearization();
        void argShowLinearization();
        void argShowXref();
        void argShowObject(char* parameter);
        void argRawStreamData();
        void argFilteredStreamData();
        void argShowNpages();
        void argShowPages();
        void argWithImages();
        void argJson();
        void argJsonKey(char* parameter);
        void argJsonObject(char* parameter);
        void argCheck();
        void argOptimizeImages();
        void argExternalizeInlineImages();
        void argKeepInlineImages();
        void argRemovePageLabels();
        void argOiMinWidth(char* parameter);
        void argOiMinHeight(char* parameter);
        void argOiMinArea(char* parameter);
        void argIiMinBytes(char* parameter);
        void arg40Print(char* parameter);
        void arg40Modify(char* parameter);
        void arg40Extract(char* parameter);
        void arg40Annotate(char* parameter);
        void arg128Accessibility(char* parameter);
        void arg128Extract(char* parameter);
        void arg128Print(char* parameter);
        void arg128Modify(char* parameter);
        void arg128ClearTextMetadata();
        void arg128Assemble(char* parameter);
        void arg128Annotate(char* parameter);
        void arg128Form(char* parameter);
        void arg128ModOther(char* parameter);
        void arg128UseAes(char* parameter);
        void arg128ForceV4();
        void arg256ForceR5();
        void argEncryptPositional(char* arg);
        void argEndEncrypt();
        void argUOpositional(char* arg);
        void argUOto(char* parameter);
        void argUOfrom(char* parameter);
        void argUOrepeat(char* parameter);
        void argUOpassword(char* parameter);
        void argEndUnderOverlay();
        void argReplaceInput();
        void argIsEncrypted();
        void argRequiresPassword();
        void argAApositional(char* arg);
        void argAAKey(char* parameter);
        void argAAFilename(char* parameter);
        void argAACreationDate(char* parameter);
        void argAAModDate(char* parameter);
        void argAAMimeType(char* parameter);
        void argAADescription(char* parameter);
        void argAAReplace();
        void argEndAddAttachment();
        void argCApositional(char* arg);
        void argCAprefix(char* parameter);
        void argCApassword(char* parameter);
        void argEndCopyAttachments();

        void usage(std::string const& message);
        void initOptionTable();
        void doFinalChecks();
        void parseUnderOverlayOptions(QPDFJob::UnderOverlay*);
        void parseRotationParameter(std::string const&);
        std::vector<int> parseNumrange(char const* range, int max,
                                       bool throw_error = false);

        QPDFArgParser ap;
        QPDFJob& o;
        std::vector<char*> accumulated_args; // points to member in ap
        char* pages_password;
    };
}

ArgParser::ArgParser(QPDFArgParser& ap, QPDFJob& o) :
    ap(ap),
    o(o),
    pages_password(nullptr)
{
    initOptionTable();
}

void
ArgParser::initOptionTable()
{
    auto b = [this](void (ArgParser::*f)()) {
        return QPDFArgParser::bindBare(f, this);
    };
    auto p = [this](void (ArgParser::*f)(char *)) {
        return QPDFArgParser::bindParam(f, this);
    };

    this->ap.addFinalCheck(b(&ArgParser::doFinalChecks));

    this->ap.selectHelpOptionTable();
    this->ap.addBare("help", b(&ArgParser::argHelp));
    this->ap.addBare("version", b(&ArgParser::argVersion));
    this->ap.addBare("copyright", b(&ArgParser::argCopyright));
    this->ap.addBare("json-help", b(&ArgParser::argJsonHelp));
    this->ap.addBare("show-crypto", b(&ArgParser::argShowCrypto));

    this->ap.selectMainOptionTable();
    char const* yn[] = {"y", "n", 0};
    this->ap.addPositional(p(&ArgParser::argPositional));
    this->ap.addRequiredParameter("password",
        p(&ArgParser::argPassword), "password");
    this->ap.addRequiredParameter("password-file",
        p(&ArgParser::argPasswordFile), "password-file");
    this->ap.addBare("empty", b(&ArgParser::argEmpty));
    this->ap.addBare("linearize", b(&ArgParser::argLinearize));
    this->ap.addBare("decrypt", b(&ArgParser::argDecrypt));
    this->ap.addBare("password-is-hex-key", b(&ArgParser::argPasswordIsHexKey));
    this->ap.addBare("suppress-password-recovery",
                     b(&ArgParser::argSuppressPasswordRecovery));
    char const* password_mode_choices[] =
        {"bytes", "hex-bytes", "unicode", "auto", 0};
    this->ap.addRequiredChoices("password-mode",
        p(&ArgParser::argPasswordMode), password_mode_choices);
    this->ap.addRequiredParameter("copy-encryption",
        p(&ArgParser::argCopyEncryption), "file");
    this->ap.addRequiredParameter("encryption-file-password",
        p(&ArgParser::argEncryptionFilePassword), "password");
    this->ap.addRequiredParameter("rotate",
        p(&ArgParser::argRotate), "[+|-]angle:page-range");
    char const* stream_data_choices[] =
        {"compress", "preserve", "uncompress", 0};
    this->ap.addOptionalParameter("collate",p(&ArgParser::argCollate));
    this->ap.addBare("flatten-rotation", b(&ArgParser::argFlattenRotation));
    this->ap.addBare("list-attachments", b(&ArgParser::argListAttachments));
    this->ap.addRequiredParameter("show-attachment",
        p(&ArgParser::argShowAttachment), "attachment-key");
    this->ap.addRequiredParameter("remove-attachment",
        p(&ArgParser::argRemoveAttachment), "attachment-key");
    this->ap.addBare("add-attachment", b(&ArgParser::argAddAttachment));
    this->ap.addBare(
        "copy-attachments-from", b(&ArgParser::argCopyAttachments));
    this->ap.addRequiredChoices("stream-data",
        p(&ArgParser::argStreamData), stream_data_choices);
    this->ap.addRequiredChoices("compress-streams",
        p(&ArgParser::argCompressStreams), yn);
    this->ap.addBare("recompress-flate", b(&ArgParser::argRecompressFlate));
    this->ap.addRequiredParameter("compression-level",
        p(&ArgParser::argCompressionLevel), "level");
    char const* decode_level_choices[] =
        {"none", "generalized", "specialized", "all", 0};
    this->ap.addRequiredChoices("decode-level",
        p(&ArgParser::argDecodeLevel), decode_level_choices);
    this->ap.addRequiredChoices("normalize-content",
        p(&ArgParser::argNormalizeContent), yn);
    this->ap.addBare("suppress-recovery", b(&ArgParser::argSuppressRecovery));
    char const* object_streams_choices[] = {
        "disable", "preserve", "generate", 0};
    this->ap.addRequiredChoices("object-streams",
        p(&ArgParser::argObjectStreams), object_streams_choices);
    this->ap.addBare(
        "ignore-xref-streams", b(&ArgParser::argIgnoreXrefStreams));
    this->ap.addBare("qdf", b(&ArgParser::argQdf));
    this->ap.addBare(
        "preserve-unreferenced", b(&ArgParser::argPreserveUnreferenced));
    this->ap.addBare(
        "preserve-unreferenced-resources",
        b(&ArgParser::argPreserveUnreferencedResources));
    char const* remove_unref_choices[] = {
        "auto", "yes", "no", 0};
    this->ap.addRequiredChoices("remove-unreferenced-resources",
        p(&ArgParser::argRemoveUnreferencedResources), remove_unref_choices);
    this->ap.addRequiredChoices("keep-files-open",
        p(&ArgParser::argKeepFilesOpen), yn);
    this->ap.addRequiredParameter("keep-files-open-threshold",
        p(&ArgParser::argKeepFilesOpenThreshold), "count");
    this->ap.addBare("newline-before-endstream", b(&ArgParser::argNewlineBeforeEndstream));
    this->ap.addRequiredParameter("linearize-pass1",
        p(&ArgParser::argLinearizePass1), "filename");
    this->ap.addBare("coalesce-contents", b(&ArgParser::argCoalesceContents));
    char const* flatten_choices[] = {"all", "print", "screen", 0};
    this->ap.addRequiredChoices("flatten-annotations",
        p(&ArgParser::argFlattenAnnotations), flatten_choices);
    this->ap.addBare("generate-appearances", b(&ArgParser::argGenerateAppearances));
    this->ap.addRequiredParameter("min-version",
        p(&ArgParser::argMinVersion), "version");
    this->ap.addRequiredParameter("force-version",
        p(&ArgParser::argForceVersion), "version");
    this->ap.addOptionalParameter("split-pages",p(&ArgParser::argSplitPages));
    this->ap.addBare("verbose", b(&ArgParser::argVerbose));
    this->ap.addBare("progress", b(&ArgParser::argProgress));
    this->ap.addBare("no-warn", b(&ArgParser::argNoWarn));
    this->ap.addBare("warning-exit-0", b(&ArgParser::argWarningExitZero));
    this->ap.addBare("deterministic-id", b(&ArgParser::argDeterministicId));
    this->ap.addBare("static-id", b(&ArgParser::argStaticId));
    this->ap.addBare("static-aes-iv", b(&ArgParser::argStaticAesIv));
    this->ap.addBare("no-original-object-ids", b(&ArgParser::argNoOriginalObjectIds));
    this->ap.addBare("show-encryption", b(&ArgParser::argShowEncryption));
    this->ap.addBare("show-encryption-key", b(&ArgParser::argShowEncryptionKey));
    this->ap.addBare("check-linearization", b(&ArgParser::argCheckLinearization));
    this->ap.addBare("show-linearization", b(&ArgParser::argShowLinearization));
    this->ap.addBare("show-xref", b(&ArgParser::argShowXref));
    this->ap.addRequiredParameter("show-object",
        p(&ArgParser::argShowObject), "trailer|obj[,gen]");
    this->ap.addBare("raw-stream-data", b(&ArgParser::argRawStreamData));
    this->ap.addBare("filtered-stream-data", b(&ArgParser::argFilteredStreamData));
    this->ap.addBare("show-npages", b(&ArgParser::argShowNpages));
    this->ap.addBare("show-pages", b(&ArgParser::argShowPages));
    this->ap.addBare("with-images", b(&ArgParser::argWithImages));
    this->ap.addBare("json", b(&ArgParser::argJson));
    // QXXXQ
    // The list of selectable top-level keys id duplicated in three
    // places: json_schema, do_json, and initOptionTable.
    char const* json_key_choices[] = {
        "objects", "objectinfo", "pages", "pagelabels", "outlines",
        "acroform", "encrypt", "attachments", 0};
    this->ap.addRequiredChoices("json-key",
        p(&ArgParser::argJsonKey), json_key_choices);
    this->ap.addRequiredParameter("json-object",
        p(&ArgParser::argJsonObject), "trailer|obj[,gen]");
    this->ap.addBare("check", b(&ArgParser::argCheck));
    this->ap.addBare("optimize-images", b(&ArgParser::argOptimizeImages));
    this->ap.addBare("externalize-inline-images", b(&ArgParser::argExternalizeInlineImages));
    this->ap.addBare("keep-inline-images", b(&ArgParser::argKeepInlineImages));
    this->ap.addBare("remove-page-labels", b(&ArgParser::argRemovePageLabels));
    this->ap.addRequiredParameter("oi-min-width",
        p(&ArgParser::argOiMinWidth), "minimum-width");
    this->ap.addRequiredParameter("oi-min-height",
        p(&ArgParser::argOiMinHeight), "minimum-height");
    this->ap.addRequiredParameter("oi-min-area",
        p(&ArgParser::argOiMinArea), "minimum-area");
    this->ap.addRequiredParameter("ii-min-bytes",
        p(&ArgParser::argIiMinBytes), "minimum-bytes");
    this->ap.addBare("overlay", b(&ArgParser::argOverlay));
    this->ap.addBare("underlay", b(&ArgParser::argUnderlay));
    this->ap.addBare("replace-input", b(&ArgParser::argReplaceInput));
    this->ap.addBare("is-encrypted", b(&ArgParser::argIsEncrypted));
    this->ap.addBare("requires-password", b(&ArgParser::argRequiresPassword));
    this->ap.addBare("allow-weak-crypto", b(&ArgParser::argAllowWeakCrypto));

    this->ap.selectMainOptionTable();
    this->ap.addBare("pages", b(&ArgParser::argPages));
    this->ap.registerOptionTable(O_PAGES, b(&ArgParser::argEndPages));
    this->ap.addRequiredParameter(
        "password", p(&ArgParser::argPagesPassword), "password");
    this->ap.addPositional(p(&ArgParser::argPagesPositional));

    this->ap.selectMainOptionTable();
    this->ap.addBare("encrypt", b(&ArgParser::argEncrypt));
    this->ap.registerOptionTable(O_ENCRYPT, b(&ArgParser::argEndEncrypt));
    this->ap.addPositional(p(&ArgParser::argEncryptPositional));
    this->ap.registerOptionTable(O_ENCRYPT_40, b(&ArgParser::argEndEncrypt));
    this->ap.addRequiredChoices("extract",p(&ArgParser::arg40Extract), yn);
    this->ap.addRequiredChoices("annotate",p(&ArgParser::arg40Annotate), yn);
    this->ap.addRequiredChoices("print",p(&ArgParser::arg40Print), yn);
    this->ap.addRequiredChoices("modify",p(&ArgParser::arg40Modify), yn);
    this->ap.registerOptionTable(O_ENCRYPT_128, b(&ArgParser::argEndEncrypt));
    this->ap.registerOptionTable(O_ENCRYPT_256, b(&ArgParser::argEndEncrypt));
    for (char const* k: {O_ENCRYPT_128, O_ENCRYPT_256})
    {
        this->ap.selectOptionTable(k);
        this->ap.addRequiredChoices("accessibility",
                                    p(&ArgParser::arg128Accessibility), yn);
        this->ap.addRequiredChoices("extract", p(&ArgParser::arg128Extract), yn);
        char const* print128_choices[] = {"full", "low", "none", 0};
        this->ap.addRequiredChoices("print",
                                    p(&ArgParser::arg128Print), print128_choices);
        this->ap.addRequiredChoices("assemble",p(&ArgParser::arg128Assemble), yn);
        this->ap.addRequiredChoices("annotate",p(&ArgParser::arg128Annotate), yn);
        this->ap.addRequiredChoices("form",p(&ArgParser::arg128Form), yn);
        this->ap.addRequiredChoices("modify-other",p(&ArgParser::arg128ModOther), yn);
        char const* modify128_choices[] =
            {"all", "annotate", "form", "assembly", "none", 0};
        this->ap.addRequiredChoices("modify",
                                    p(&ArgParser::arg128Modify), modify128_choices);
        this->ap.addBare("cleartext-metadata", b(&ArgParser::arg128ClearTextMetadata));
    }

    this->ap.selectOptionTable(O_ENCRYPT_128);
    this->ap.addRequiredChoices("use-aes",p(&ArgParser::arg128UseAes), yn);
    this->ap.addBare("force-V4", b(&ArgParser::arg128ForceV4));

    this->ap.selectOptionTable(O_ENCRYPT_256);
    this->ap.addBare("force-R5", b(&ArgParser::arg256ForceR5));
    this->ap.addBare("allow-insecure", b(&ArgParser::argAllowInsecure));

    this->ap.registerOptionTable(O_UNDER_OVERLAY, b(&ArgParser::argEndUnderOverlay));
    this->ap.addPositional(p(&ArgParser::argUOpositional));
    this->ap.addRequiredParameter("to",
        p(&ArgParser::argUOto), "page-range");
    this->ap.addRequiredParameter("from",
        p(&ArgParser::argUOfrom), "page-range");
    this->ap.addRequiredParameter("repeat",
        p(&ArgParser::argUOrepeat), "page-range");
    this->ap.addRequiredParameter("password",
        p(&ArgParser::argUOpassword), "password");

    this->ap.registerOptionTable(O_ATTACHMENT, b(&ArgParser::argEndAddAttachment));
    this->ap.addPositional(p(&ArgParser::argAApositional));
    this->ap.addRequiredParameter("key",
        p(&ArgParser::argAAKey), "attachment-key");
    this->ap.addRequiredParameter("filename",
        p(&ArgParser::argAAFilename), "filename");
    this->ap.addRequiredParameter("creationdate",
        p(&ArgParser::argAACreationDate), "creation-date");
    this->ap.addRequiredParameter("moddate",
        p(&ArgParser::argAAModDate), "modification-date");
    this->ap.addRequiredParameter("mimetype",
        p(&ArgParser::argAAMimeType), "mime/type");
    this->ap.addRequiredParameter("description",
        p(&ArgParser::argAADescription), "description");
    this->ap.addBare("replace", b(&ArgParser::argAAReplace));

    this->ap.registerOptionTable(O_COPY_ATTACHMENT, b(&ArgParser::argEndCopyAttachments));
    this->ap.addPositional(p(&ArgParser::argCApositional));
    this->ap.addRequiredParameter("prefix",
        p(&ArgParser::argCAprefix), "prefix");
    this->ap.addRequiredParameter("password",
        p(&ArgParser::argCApassword), "password");
}

void
ArgParser::argPositional(char* arg)
{
    if (o.infilename == 0)
    {
        o.infilename = arg;
    }
    else if (o.outfilename == 0)
    {
        o.outfilename = arg;
    }
    else
    {
        usage(std::string("unknown argument ") + arg);
    }
}

void
ArgParser::argVersion()
{
    auto whoami = this->ap.getProgname();
    std::cout
        << whoami << " version " << QPDF::QPDFVersion() << std::endl
        << "Run " << whoami << " --copyright to see copyright and license information."
        << std::endl;
}

void
ArgParser::argCopyright()
{
    // Make sure the output looks right on an 80-column display.
    //               1         2         3         4         5         6         7         8
    //      12345678901234567890123456789012345678901234567890123456789012345678901234567890
    std::cout
        << this->ap.getProgname()
        << " version " << QPDF::QPDFVersion() << std::endl
        << std::endl
        << "Copyright (c) 2005-2021 Jay Berkenbilt"
        << std::endl
        << "QPDF is licensed under the Apache License, Version 2.0 (the \"License\");"
        << std::endl
        << "you may not use this file except in compliance with the License."
        << std::endl
        << "You may obtain a copy of the License at"
        << std::endl
        << std::endl
        << "  http://www.apache.org/licenses/LICENSE-2.0"
        << std::endl
        << std::endl
        << "Unless required by applicable law or agreed to in writing, software"
        << std::endl
        << "distributed under the License is distributed on an \"AS IS\" BASIS,"
        << std::endl
        << "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied."
        << std::endl
        << "See the License for the specific language governing permissions and"
        << std::endl
        << "limitations under the License."
        << std::endl
        << std::endl
        << "Versions of qpdf prior to version 7 were released under the terms"
        << std::endl
        << "of version 2.0 of the Artistic License. At your option, you may"
        << std::endl
        << "continue to consider qpdf to be licensed under those terms. Please"
        << std::endl
        << "see the manual for additional information."
        << std::endl;
}

void
ArgParser::argHelp()
{
    std::cout
        // 12345678901234567890123456789012345678901234567890123456789012345678901234567890
        << "Usage: qpdf [options] {infile | --empty} [page_selection_options] outfile\n"
        << "\n"
        << "An option summary appears below.  Please see the documentation for details.\n"
        << "\n"
        << "If @filename appears anywhere in the command-line, each line of filename\n"
        << "will be interpreted as an argument. No interpolation is done. Line\n"
        << "terminators are stripped, but leading and trailing whitespace is\n"
        << "intentionally preserved. @- can be specified to read from standard input.\n"
        << "\n"
        << "The output file can be - to indicate writing to standard output, or it can\n"
        << "be --replace-input to cause qpdf to replace the input file with the output.\n"
        << "\n"
        << "Note that when contradictory options are provided, whichever options are\n"
        << "provided last take precedence.\n"
        << "\n"
        << "\n"
        << "Basic Options\n"
        << "-------------\n"
        << "\n"
        << "--version               show version of qpdf\n"
        << "--copyright             show qpdf's copyright and license information\n"
        << "--help                  show command-line argument help\n"
        << "--show-crypto           show supported crypto providers; default is first\n"
        << "--completion-bash       output a bash complete command you can eval\n"
        << "--completion-zsh        output a zsh complete command you can eval\n"
        << "--password=password     specify a password for accessing encrypted files\n"
        << "--password-file=file    get the password the first line \"file\"; use \"-\"\n"
        << "                        to read the password from stdin (without prompt or\n"
        << "                        disabling echo, so use with caution)\n"
        << "--is-encrypted          silently exit 0 if the file is encrypted or 2\n"
        << "                        if not; useful for shell scripts\n"
        << "--requires-password     silently exit 0 if a password (other than as\n"
        << "                        supplied) is required, 2 if the file is not\n"
        << "                        encrypted, or 3 if the file is encrypted\n"
        << "                        but requires no password or the supplied password\n"
        << "                        is correct; useful for shell scripts\n"
        << "--verbose               provide additional informational output\n"
        << "--progress              give progress indicators while writing output\n"
        << "--no-warn               suppress warnings\n"
        << "--warning-exit-0        exit with code 0 instead of 3 if there are warnings\n"
        << "--linearize             generated a linearized (web optimized) file\n"
        << "--replace-input         use in place of specifying an output file; qpdf will\n"
        << "                        replace the input file with the output\n"
        << "--copy-encryption=file  copy encryption parameters from specified file\n"
        << "--encryption-file-password=password\n"
        << "                        password used to open the file from which encryption\n"
        << "                        parameters are being copied\n"
        << "--allow-weak-crypto     allow creation of files using weak cryptographic\n"
        << "                        algorithms\n"
        << "--encrypt options --    generate an encrypted file\n"
        << "--decrypt               remove any encryption on the file\n"
        << "--password-is-hex-key   treat primary password option as a hex-encoded key\n"
        << "--suppress-password-recovery\n"
        << "                        do not attempt recovering from password string\n"
        << "                        encoding errors\n"
        << "--password-mode=mode    control qpdf's encoding of passwords\n"
        << "--pages options --      select specific pages from one or more files\n"
        << "--collate=n             causes files specified in --pages to be collated\n"
        << "                        in groups of n pages (default 1) rather than\n"
        << "                        concatenated\n"
        << "--flatten-rotation      move page rotation from /Rotate key to content\n"
        << "--rotate=[+|-]angle[:page-range]\n"
        << "                        rotate each specified page 0, 90, 180, or 270\n"
        << "                        degrees; rotate all pages if no page range is given\n"
        << "--split-pages=[n]       write each output page to a separate file\n"
        << "--overlay options --    overlay pages from another file\n"
        << "--underlay options --   underlay pages from another file\n"
        << "\n"
        << "Note that you can use the @filename or @- syntax for any argument at any\n"
        << "point in the command. This provides a good way to specify a password without\n"
        << "having to explicitly put it on the command line. @filename or @- must be a\n"
        << "word by itself. Syntax such as --arg=@filename doesn't work.\n"
        << "\n"
        << "If none of --copy-encryption, --encrypt or --decrypt are given, qpdf will\n"
        << "preserve any encryption data associated with a file.\n"
        << "\n"
        << "Note that when copying encryption parameters from another file, all\n"
        << "parameters will be copied, including both user and owner passwords, even\n"
        << "if the user password is used to open the other file.  This works even if\n"
        << "the owner password is not known.\n"
        << "\n"
        << "The --password-is-hex-key option overrides the normal computation of\n"
        << "encryption keys. It only applies to the password used to open the main\n"
        << "file. This option is not ordinarily useful but can be helpful for forensic\n"
        << "or investigatory purposes. See manual for further discussion.\n"
        << "\n"
        << "The --rotate flag can be used to specify pages to rotate pages either\n"
        << "0, 90, 180, or 270 degrees. The page range is specified in the same\n"
        << "format as with the --pages option, described below. Repeat the option\n"
        << "to rotate multiple groups of pages. If the angle is preceded by + or -,\n"
        << "it is added to or subtracted from the original rotation. Otherwise, the\n"
        << "rotation angle is set explicitly to the given value. You almost always\n"
        << "want to use + or - unless you are certain about the internals of the PDF\n"
        << "you are working with.\n"
        << "\n"
        << "If --split-pages is specified, each page is written to a separate output\n"
        << "file. File names are generated as follows:\n"
        << "* If the string %d appears in the output file name, it is replaced with a\n"
        << "  zero-padded page range starting from 1\n"
        << "* Otherwise, if the output file name ends in .pdf (case insensitive), a\n"
        << "  zero-padded page range, preceded by a dash, is inserted before the file\n"
        << "  extension\n"
        << "* Otherwise, the file name is appended with a zero-padded page range\n"
        << "  preceded by a dash.\n"
        << "Page ranges are single page numbers for single-page groups or first-last\n"
        << "for multipage groups.\n"
        << "\n"
        << "\n"
        << "Encryption Options\n"
        << "------------------\n"
        << "\n"
        << "  --encrypt user-password owner-password key-length flags --\n"
        << "\n"
        << "Note that -- terminates parsing of encryption flags.\n"
        << "\n"
        << "Either or both of the user password and the owner password may be\n"
        << "empty strings.\n"
        << "\n"
        << "key-length may be 40, 128, or 256\n"
        << "\n"
        << "Additional flags are dependent upon key length.\n"
        << "\n"
        << "  If 40:\n"
        << "\n"
        << "    --print=[yn]             allow printing\n"
        << "    --modify=[yn]            allow document modification\n"
        << "    --extract=[yn]           allow text/graphic extraction\n"
        << "    --annotate=[yn]          allow comments and form fill-in and signing\n"
        << "\n"
        << "  If 128:\n"
        << "\n"
        << "    --accessibility=[yn]     allow accessibility to visually impaired\n"
        << "    --extract=[yn]           allow other text/graphic extraction\n"
        << "    --print=print-opt        control printing access\n"
        << "    --assemble=[yn]          allow document assembly\n"
        << "    --annotate=[yn]          allow commenting/filling form fields\n"
        << "    --form=[yn]              allow filling form fields\n"
        << "    --modify-other=[yn]      allow other modifications\n"
        << "    --modify=modify-opt      control modify access (old way)\n"
        << "    --cleartext-metadata     prevents encryption of metadata\n"
        << "    --use-aes=[yn]           indicates whether to use AES encryption\n"
        << "    --force-V4               forces use of V=4 encryption handler\n"
        << "\n"
        << "  If 256, options are the same as 128 with these exceptions:\n"
        << "    --force-V4               this option is not available with 256-bit keys\n"
        << "    --use-aes                this option is always on with 256-bit keys\n"
        << "    --force-R5               forces use of deprecated R=5 encryption\n"
        << "    --allow-insecure         allow the owner password to be empty when the\n"
        << "                             user password is not empty\n"
        << "\n"
        << "    print-opt may be:\n"
        << "\n"
        << "      full                  allow full printing\n"
        << "      low                   allow only low-resolution printing\n"
        << "      none                  disallow printing\n"
        << "\n"
        << "    modify-opt may be:\n"
        << "\n"
        << "      all                   allow full document modification\n"
        << "      annotate              allow comment authoring and form operations\n"
        << "      form                  allow form field fill-in and signing\n"
        << "      assembly              allow document assembly only\n"
        << "      none                  allow no modifications\n"
        << "\n"
        << "The default for each permission option is to be fully permissive. Please\n"
        << "refer to the manual for more details on the modify options.\n"
        << "\n"
        << "Specifying cleartext-metadata forces the PDF version to at least 1.5.\n"
        << "Specifying use of AES forces the PDF version to at least 1.6.  These\n"
        << "options are both off by default.\n"
        << "\n"
        << "The --force-V4 flag forces the V=4 encryption handler introduced in PDF 1.5\n"
        << "to be used even if not otherwise needed.  This option is primarily useful\n"
        << "for testing qpdf and has no other practical use.\n"
        << "\n"
        << "A warning will be issued if you attempt to encrypt a file with a format that\n"
        << "uses a weak cryptographic algorithm such as RC4. To suppress the warning,\n"
        << "specify the option --allow-weak-crypto. This option is outside of encryption\n"
        << "options (e.g. --allow-week-crypto --encrypt u o 128 --)\n"
        << "\n"
        << "\n"
        << "Password Modes\n"
        << "--------------\n"
        << "\n"
        << "The --password-mode controls how qpdf interprets passwords supplied\n"
        << "on the command-line. qpdf's default behavior is correct in almost all\n"
        << "cases, but you can fine-tune with this option.\n"
        << "\n"
        << "  bytes: use the password literally as supplied\n"
        << "  hex-bytes: interpret the password as a hex-encoded byte string\n"
        << "  unicode: interpret the password as a UTF-8 encoded string\n"
        << "  auto: attempt to infer the encoding and adjust as needed\n"
        << "\n"
        << "This is a complex topic. See the manual for a complete discussion.\n"
        << "\n"
        << "\n"
        << "Page Selection Options\n"
        << "----------------------\n"
        << "\n"
        << "These options allow pages to be selected from one or more PDF files.\n"
        << "Whatever file is given as the primary input file is used as the\n"
        << "starting point, but its pages are replaced with pages as specified.\n"
        << "\n"
        << "--keep-files-open=[yn]\n"
        << "--keep-files-open-threshold=count\n"
        << "--pages file [ --password=password ] [ page-range ] ... --\n"
        << "\n"
        << "For each file that pages should be taken from, specify the file, a\n"
        << "password needed to open the file (if any), and a page range.  The\n"
        << "password needs to be given only once per file.  If any of the input\n"
        << "files are the same as the primary input file or the file used to copy\n"
        << "encryption parameters (if specified), you do not need to repeat the\n"
        << "password here.  The same file can be repeated multiple times.  The\n"
        << "filename \".\" may be used to refer to the current input file.  All\n"
        << "non-page data (info, outlines, page numbers, etc. are taken from the\n"
        << "primary input file.  To discard this, use --empty as the primary\n"
        << "input.\n"
        << "\n"
        << "By default, when more than 200 distinct files are specified, qpdf will\n"
        << "close each file when not being referenced. With 200 files or fewer, all\n"
        << "files will be kept open at the same time. This behavior can be overridden\n"
        << "by specifying --keep-files-open=[yn]. Closing and opening files can have\n"
        << "very high overhead on certain file systems, especially networked file\n"
        << "systems. The threshold of 200 can be modified with\n"
        << "--keep-files-open-threshold\n"
        << "\n"
        << "The page range is a set of numbers separated by commas, ranges of\n"
        << "numbers separated dashes, or combinations of those.  The character\n"
        << "\"z\" represents the last page.  A number preceded by an \"r\" indicates\n"
        << "to count from the end, so \"r3-r1\" would be the last three pages of the\n"
        << "document.  Pages can appear in any order.  Ranges can appear with a\n"
        << "high number followed by a low number, which causes the pages to appear in\n"
        << "reverse.  Numbers may be repeated.  A page range may be appended with :odd\n"
        << "to indicate odd pages in the selected range or :even to indicate even\n"
        << "pages.\n"
        << "\n"
        << "If the page range is omitted, the range of 1-z is assumed.  qpdf decides\n"
        << "that the page range is omitted if the range argument is either -- or a\n"
        << "valid file name and not a valid range.\n"
        << "\n"
        << "The usual behavior of --pages is to add all pages from the first file,\n"
        << "then all pages from the second file, and so on. If the --collate option\n"
        << "is specified, then pages are collated instead. In other words, qpdf takes\n"
        << "the first page from the first file, the first page from the second file,\n"
        << "and so on until it runs out of files; then it takes the second page from\n"
        << "each file, etc. When a file runs out of pages, it is skipped until all\n"
        << "specified pages are taken from all files.\n"
        << "\n"
        << "See the manual for examples and a discussion of additional subtleties.\n"
        << "\n"
        << "\n"
        << "Overlay and Underlay Options\n"
        << "----------------------------\n"
        << "\n"
        << "These options allow pages from another file to be overlaid or underlaid\n"
        << "on the primary output. Overlaid pages are drawn on top of the destination\n"
        << "page and may obscure the page. Underlaid pages are drawn below the\n"
        << "destination page.\n"
        << "\n"
        << "{--overlay | --underlay } file\n"
        "      [ --password=password ]\n"
        "      [ --to=page-range ]\n"
        "      [ --from=[page-range] ]\n"
        "      [ --repeat=page-range ]\n"
        "      --\n"
        << "\n"
        << "For overlay and underlay, a file and optional password are specified, along\n"
        << "with a series of optional page ranges. The default behavior is that each\n"
        << "page of the overlay or underlay file is imposed on the corresponding page\n"
        << "of the primary output until it runs out of pages, and any extra pages are\n"
        << "ignored. The page range options all take page ranges in the same form as\n"
        << "the --pages option. They have the following meanings:\n"
        << "\n"
        << "  --to:     the pages in the primary output to which overlay/underlay is\n"
        << "            applied\n"
        << "  --from:   the pages from the overlay/underlay file that are used\n"
        << "  --repeat: pages from the overlay/underlay that are repeated after\n"
        << "            any \"from\" pages have been exhausted\n"
        << "\n"
        << "\n"
        << "Embedded Files/Attachments Options\n"
        << "----------------------------------\n"
        << "\n"
        << "These options can be used to work with embedded files, also known as\n"
        << "attachments.\n"
        << "\n"
        << "--list-attachments        show key and stream number for embedded files;\n"
        << "                          combine with --verbose for more detailed information\n"
        << "--show-attachment=key     write the contents of the specified attachment to\n"
        << "                          standard output as binary data\n"
        << "--add-attachment file options --\n"
        << "                          add or replace an attachment\n"
        << "--remove-attachment=key   remove the specified attachment; repeatable\n"
        << "--copy-attachments-from file options --\n"
        << "                          copy attachments from another file\n"
        << "\n"
        << "The \"key\" option is the unique name under which the attachment is registered\n"
        << "within the PDF file. You can get this using the --list-attachments option. This\n"
        << "is usually the same as the filename, but it doesn't have to be.\n"
        << "\n"
        << "Options for adding attachments:\n"
        << "\n"
        << "  file                    path to the file to attach\n"
        << "  --key=key               the name of this in the embedded files table;\n"
        << "                          defaults to the last path element of file\n"
        << "  --filename=name         the file name of the attachment; this is what is\n"
        << "                          usually displayed to the user; defaults to the\n"
        << "                          last path element of file\n"
        << "  --creationdate=date     creation date in PDF format; defaults to the\n"
        << "                          current time\n"
        << "  --moddate=date          modification date in PDF format; defaults to the\n"
        << "                          current time\n"
        << "  --mimetype=type/subtype   mime type of attachment (e.g. application/pdf)\n"
        << "  --description=\"text\"    attachment description\n"
        << "  --replace               replace any existing attachment with the same key\n"
        << "\n"
        << "Options for copying attachments:\n"
        << "\n"
        << "  file                    file whose attachments should be copied\n"
        << "  --password=password     password to open the other file, if needed\n"
        << "  --prefix=prefix         a prefix to insert in front of each key;\n"
        << "                          required if needed to ensure each attachment\n"
        << "                          has a unique key\n"
        << "\n"
        << "Date format: D:yyyymmddhhmmss<z> where <z> is either Z for UTC or a timezone\n"
        << "offset in the form -hh'mm' or +hh'mm'.\n"
        << "Examples: D:20210207161528-05'00', D:20210207211528Z\n"
        << "\n"
        << "\n"
        << "Advanced Parsing Options\n"
        << "------------------------\n"
        << "\n"
        << "These options control aspects of how qpdf reads PDF files. Mostly these are\n"
        << "of use to people who are working with damaged files. There is little reason\n"
        << "to use these options unless you are trying to solve specific problems.\n"
        << "\n"
        << "--suppress-recovery       prevents qpdf from attempting to recover damaged files\n"
        << "--ignore-xref-streams     tells qpdf to ignore any cross-reference streams\n"
        << "\n"
        << "\n"
        << "Advanced Transformation Options\n"
        << "-------------------------------\n"
        << "\n"
        << "These transformation options control fine points of how qpdf creates\n"
        << "the output file.  Mostly these are of use only to people who are very\n"
        << "familiar with the PDF file format or who are PDF developers.\n"
        << "\n"
        << "--stream-data=option      controls transformation of stream data (below)\n"
        << "--compress-streams=[yn]   controls whether to compress streams on output\n"
        << "--decode-level=option     controls how to filter streams from the input\n"
        << "--recompress-flate        recompress streams already compressed with Flate\n"
        << "--compression-level=n     set zlib compression level; most effective with\n"
        << "                          --recompress-flate --object-streams=generate\n"
        << "--normalize-content=[yn]  enables or disables normalization of content streams\n"
        << "--object-streams=mode     controls handing of object streams\n"
        << "--preserve-unreferenced   preserve unreferenced objects\n"
        << "--remove-unreferenced-resources={auto,yes,no}\n"
        << "                          whether to remove unreferenced page resources\n"
        << "--preserve-unreferenced-resources\n"
        << "                          synonym for --remove-unreferenced-resources=no\n"
        << "--newline-before-endstream  always put a newline before endstream\n"
        << "--coalesce-contents       force all pages' content to be a single stream\n"
        << "--flatten-annotations=option\n"
        << "                          incorporate rendering of annotations into page\n"
        << "                          contents including those for interactive form\n"
        << "                          fields; may also want --generate-appearances\n"
        << "--generate-appearances    generate appearance streams for form fields\n"
        << "--optimize-images         compress images with DCT (JPEG) when advantageous\n"
        << "--oi-min-width=w          do not optimize images whose width is below w;\n"
        << "                          default is 128. Use 0 to mean no minimum\n"
        << "--oi-min-height=h         do not optimize images whose height is below h\n"
        << "                          default is 128. Use 0 to mean no minimum\n"
        << "--oi-min-area=a           do not optimize images whose pixel count is below a\n"
        << "                          default is 16,384. Use 0 to mean no minimum\n"
        << "--externalize-inline-images  convert inline images to regular images; by\n"
        << "                          default, images of at least 1,024 bytes are\n"
        << "                          externalized\n"
        << "--ii-min-bytes=bytes      specify minimum size of inline images to be\n"
        << "                          converted to regular images\n"
        << "--keep-inline-images      exclude inline images from image optimization\n"
        << "--remove-page-labels      remove any page labels present in the output file\n"
        << "--qdf                     turns on \"QDF mode\" (below)\n"
        << "--linearize-pass1=file    write intermediate pass of linearized file\n"
        << "                          for debugging\n"
        << "--min-version=version     sets the minimum PDF version of the output file\n"
        << "--force-version=version   forces this to be the PDF version of the output file\n"
        << "\n"
        << "Options for --flatten-annotations are all, print, or screen. If the option\n"
        << "is print, only annotations marked as print are included. If the option is\n"
        << "screen, options marked as \"no view\" are excluded. Otherwise, annotations\n"
        << "are flattened regardless of the presence of print or NoView flags. It is\n"
        << "common for PDF files to have a flag set that appearance streams need to be\n"
        << "regenerated. This happens when someone changes a form value with software\n"
        << "that does not know how to render the new value. qpdf will not flatten form\n"
        << "fields in files like this. If you get this warning, you have two choices:\n"
        << "either use qpdf's --generate-appearances flag to tell qpdf to go ahead and\n"
        << "regenerate appearances, or use some other tool to generate the appearances.\n"
        << "qpdf does a pretty good job with most forms when only ASCII and \"Windows\n"
        << "ANSI\" characters are used in form field values, but if your form fields\n"
        << "contain other characters, rich text, or are other than left justified, you\n"
        << "will get better results first saving with other software.\n"
        << "\n"
        << "Version numbers may be expressed as major.minor.extension-level, so 1.7.3\n"
        << "means PDF version 1.7 at extension level 3.\n"
        << "\n"
        << "Values for stream data options:\n"
        << "\n"
        << "  compress              recompress stream data when possible (default)\n"
        << "  preserve              leave all stream data as is\n"
        << "  uncompress            uncompress stream data when possible\n"
        << "\n"
        << "Values for object stream mode:\n"
        << "\n"
        << "  preserve                  preserve original object streams (default)\n"
        << "  disable                   don't write any object streams\n"
        << "  generate                  use object streams wherever possible\n"
        << "\n"
        << "When --compress-streams=n is specified, this overrides the default behavior\n"
        << "of qpdf, which is to attempt compress uncompressed streams. Setting\n"
        << "stream data mode to uncompress or preserve has the same effect.\n"
        << "\n"
        << "The --decode-level parameter may be set to one of the following values:\n"
        << "  none              do not decode streams\n"
        << "  generalized       decode streams compressed with generalized filters\n"
        << "                    including LZW, Flate, and the ASCII encoding filters.\n"
        << "  specialized       additionally decode streams with non-lossy specialized\n"
        << "                    filters including RunLength\n"
        << "  all               additionally decode streams with lossy filters\n"
        << "                    including DCT (JPEG)\n"
        << "\n"
        << "In qdf mode, by default, content normalization is turned on, and the\n"
        << "stream data mode is set to uncompress. QDF mode does not support\n"
        << "linearized files. The --linearize flag disables qdf mode.\n"
        << "\n"
        << "Setting the minimum PDF version of the output file may raise the version\n"
        << "but will never lower it.  Forcing the PDF version of the output file may\n"
        << "set the PDF version to a lower value than actually allowed by the file's\n"
        << "contents.  You should only do this if you have no other possible way to\n"
        << "open the file or if you know that the file definitely doesn't include\n"
        << "features not supported later versions.\n"
        << "\n"
        << "Testing, Inspection, and Debugging Options\n"
        << "------------------------------------------\n"
        << "\n"
        << "These options can be useful for digging into PDF files or for use in\n"
        << "automated test suites for software that uses the qpdf library.\n"
        << "\n"
        << "--deterministic-id        generate deterministic /ID\n"
        << "--static-id               generate static /ID: FOR TESTING ONLY!\n"
        << "--static-aes-iv           use a static initialization vector for AES-CBC\n"
        << "                          This is option is not secure!  FOR TESTING ONLY!\n"
        << "--no-original-object-ids  suppress original object ID comments in qdf mode\n"
        << "--show-encryption         quickly show encryption parameters\n"
        << "--show-encryption-key     when showing encryption, reveal the actual key\n"
        << "--check-linearization     check file integrity and linearization status\n"
        << "--show-linearization      check and show all linearization data\n"
        << "--show-xref               show the contents of the cross-reference table\n"
        << "--show-object=trailer|obj[,gen]\n"
        << "                          show the contents of the given object\n"
        << "  --raw-stream-data       show raw stream data instead of object contents\n"
        << "  --filtered-stream-data  show filtered stream data instead of object contents\n"
        << "--show-npages             print the number of pages in the file\n"
        << "--show-pages              shows the object/generation number for each page\n"
        << "  --with-images           also shows the object IDs for images on each page\n"
        << "--check                   check file structure + encryption, linearization\n"
        << "--json                    generate a json representation of the file\n"
        << "--json-help               describe the format of the json representation\n"
        << "--json-key=key            repeatable; prune json structure to include only\n"
        << "                          specified keys. If absent, all keys are shown\n"
        << "--json-object=trailer|[obj,gen]\n"
        << "                          repeatable; include only specified objects in the\n"
        << "                          \"objects\" section of the json. If absent, all\n"
        << "                          objects are shown\n"
        << "\n"
        << "The json representation generated by qpdf is designed to facilitate\n"
        << "processing of qpdf from other programming languages that have a hard\n"
        << "time calling C++ APIs. Run qpdf --json-help for details on the format.\n"
        << "The manual has more in-depth information about the json representation\n"
        << "and certain compatibility guarantees that qpdf provides.\n"
        << "\n"
        << "The --raw-stream-data and --filtered-stream-data options are ignored\n"
        << "unless --show-object is given.  Either of these options will cause the\n"
        << "stream data to be written to standard output.\n"
        << "\n"
        << "If --filtered-stream-data is given and --normalize-content=y is also\n"
        << "given, qpdf will attempt to normalize the stream data as if it is a\n"
        << "page content stream.  This attempt will be made even if it is not a\n"
        << "page content stream, in which case it will produce unusable results.\n"
        << "\n"
        << "Ordinarily, qpdf exits with a status of 0 on success or a status of 2\n"
        << "if any errors occurred.  If there were warnings but not errors, qpdf\n"
        << "exits with a status of 3. If warnings would have been issued but --no-warn\n"
        << "was given, an exit status of 3 is still used. If you want qpdf to exit\n"
        << "with status 0 when there are warnings, use the --warning-exit-0 flag.\n"
        << "When --no-warn and --warning-exit-0 are used together, the effect is for\n"
        << "qpdf to completely ignore warnings.  qpdf does not use exit status 1,\n"
        << "since that is used by the shell if it can't execute qpdf.\n";
}

void
ArgParser::argJsonHelp()
{
    // Make sure the output looks right on an 80-column display.
    //               1         2         3         4         5         6         7         8
    //      12345678901234567890123456789012345678901234567890123456789012345678901234567890
    std::cout
        << "The json block below contains the same structure with the same keys as the"
        << std::endl
        << "json generated by qpdf. In the block below, the values are descriptions of"
        << std::endl
        << "the meanings of those entries. The specific contract guaranteed by qpdf in"
        << std::endl
        << "its json representation is explained in more detail in the manual. You can"
        << std::endl
        << "specify a subset of top-level keys when you invoke qpdf, but the \"version\""
        << std::endl
        << "and \"parameters\" keys will always be present. Note that the \"encrypt\""
        << std::endl
        << "key's values will be populated for non-encrypted files. Some values will"
        << std::endl
        << "be null, and others will have values that apply to unencrypted files."
        << std::endl
        << QPDFJob::json_schema().unparse()
        << std::endl;
}

void
ArgParser::argShowCrypto()
{
    auto crypto = QPDFCryptoProvider::getRegisteredImpls();
    std::string default_crypto = QPDFCryptoProvider::getDefaultProvider();
    std::cout << default_crypto << std::endl;
    for (auto const& iter: crypto)
    {
        if (iter != default_crypto)
        {
            std::cout << iter << std::endl;
        }
    }
}

void
ArgParser::argPassword(char* parameter)
{
    o.password = parameter;
}

void
ArgParser::argPasswordFile(char* parameter)
{
    std::list<std::string> lines;
    if (strcmp(parameter, "-") == 0)
    {
        QTC::TC("qpdf", "qpdf password stdin");
        lines = QUtil::read_lines_from_file(std::cin);
    }
    else
    {
        QTC::TC("qpdf", "qpdf password file");
        lines = QUtil::read_lines_from_file(parameter);
    }
    if (lines.size() >= 1)
    {
        // Make sure the memory for this stays in scope.
        o.password_alloc = std::shared_ptr<char>(
            QUtil::copy_string(lines.front().c_str()),
            std::default_delete<char[]>());
        o.password = o.password_alloc.get();

        if (lines.size() > 1)
        {
            std::cerr << this->ap.getProgname()
                      << ": WARNING: all but the first line of"
                      << " the password file are ignored" << std::endl;
        }
    }
}

void
ArgParser::argEmpty()
{
    o.infilename = "";
}

void
ArgParser::argLinearize()
{
    o.linearize = true;
}

void
ArgParser::argEncrypt()
{
    this->accumulated_args.clear();
    if (this->ap.isCompleting() && this->ap.argsLeft() == 0)
    {
        this->ap.insertCompletion("user-password");
    }
    this->ap.selectOptionTable(O_ENCRYPT);
}

void
ArgParser::argEncryptPositional(char* arg)
{
    this->accumulated_args.push_back(arg);
    size_t n_args = this->accumulated_args.size();
    if (n_args < 3)
    {
        if (this->ap.isCompleting() && (this->ap.argsLeft() == 0))
        {
            if (n_args == 1)
            {
                this->ap.insertCompletion("owner-password");
            }
            else if (n_args == 2)
            {
                this->ap.insertCompletion("40");
                this->ap.insertCompletion("128");
                this->ap.insertCompletion("256");
            }
        }
        return;
    }
    o.user_password = this->accumulated_args.at(0);
    o.owner_password = this->accumulated_args.at(1);
    std::string len_str = this->accumulated_args.at(2);
    if (len_str == "40")
    {
        o.keylen = 40;
        this->ap.selectOptionTable(O_ENCRYPT_40);
    }
    else if (len_str == "128")
    {
        o.keylen = 128;
        this->ap.selectOptionTable(O_ENCRYPT_128);
    }
    else if (len_str == "256")
    {
        o.keylen = 256;
        o.use_aes = true;
        this->ap.selectOptionTable(O_ENCRYPT_256);
    }
    else
    {
        usage("encryption key length must be 40, 128, or 256");
    }
}

void
ArgParser::argDecrypt()
{
    o.decrypt = true;
    o.encrypt = false;
    o.copy_encryption = false;
}

void
ArgParser::argPasswordIsHexKey()
{
    o.password_is_hex_key = true;
}

void
ArgParser::argSuppressPasswordRecovery()
{
    o.suppress_password_recovery = true;
}

void
ArgParser::argPasswordMode(char* parameter)
{
    if (strcmp(parameter, "bytes") == 0)
    {
        o.password_mode = QPDFJob::pm_bytes;
    }
    else if (strcmp(parameter, "hex-bytes") == 0)
    {
        o.password_mode = QPDFJob::pm_hex_bytes;
    }
    else if (strcmp(parameter, "unicode") == 0)
    {
        o.password_mode = QPDFJob::pm_unicode;
    }
    else if (strcmp(parameter, "auto") == 0)
    {
        o.password_mode = QPDFJob::pm_auto;
    }
    else
    {
        usage("invalid password-mode option");
    }
}

void
ArgParser::argAllowInsecure()
{
    o.allow_insecure = true;
}

void
ArgParser::argAllowWeakCrypto()
{
    o.allow_weak_crypto = true;
}

void
ArgParser::argCopyEncryption(char* parameter)
{
    o.encryption_file = parameter;
    o.copy_encryption = true;
    o.encrypt = false;
    o.decrypt = false;
}

void
ArgParser::argEncryptionFilePassword(char* parameter)
{
    o.encryption_file_password = parameter;
}

void
ArgParser::argCollate(char* parameter)
{
    auto n = ((parameter == 0) ? 1 :
              QUtil::string_to_uint(parameter));
    o.collate = QIntC::to_size(n);
}

void
ArgParser::argPages()
{
    if (! o.page_specs.empty())
    {
        usage("the --pages may only be specified one time");
    }
    this->accumulated_args.clear();
    this->ap.selectOptionTable(O_PAGES);
}

void
ArgParser::argPagesPassword(char* parameter)
{
    if (this->pages_password != nullptr)
    {
        QTC::TC("qpdf", "qpdf duplicated pages password");
        usage("--password already specified for this file");
    }
    if (this->accumulated_args.size() != 1)
    {
        QTC::TC("qpdf", "qpdf misplaced pages password");
        usage("in --pages, --password must immediately follow a file name");
    }
    this->pages_password = parameter;
}

void
ArgParser::argPagesPositional(char* arg)
{
    if (arg == nullptr)
    {
        if (this->accumulated_args.empty())
        {
            return;
        }
    }
    else
    {
        this->accumulated_args.push_back(arg);
    }

    char const* file = this->accumulated_args.at(0);
    char const* range = nullptr;

    size_t n_args = this->accumulated_args.size();
    if (n_args >= 2)
    {
        range = this->accumulated_args.at(1);
    }

    // See if the user omitted the range entirely, in which case we
    // assume "1-z".
    char* next_file = nullptr;
    if (range == nullptr)
    {
        if (arg == nullptr)
        {
            // The filename or password was the last argument
            QTC::TC("qpdf", "qpdf pages range omitted at end",
                    this->pages_password == nullptr ? 0 : 1);
        }
        else
        {
            // We need to accumulate some more arguments
            return;
        }
    }
    else
    {
        try
        {
            parseNumrange(range, 0, true);
        }
        catch (std::runtime_error& e1)
        {
            // The range is invalid.  Let's see if it's a file.
            if (strcmp(range, ".") == 0)
            {
                // "." means the input file.
                QTC::TC("qpdf", "qpdf pages range omitted with .");
            }
            else if (QUtil::file_can_be_opened(range))
            {
                QTC::TC("qpdf", "qpdf pages range omitted in middle");
                // Yup, it's a file.
            }
            else
            {
                // Give the range error
                usage(e1.what());
            }
            next_file = const_cast<char*>(range);
            range = nullptr;
        }
    }
    if (range == nullptr)
    {
        range = "1-z";
    }
    o.page_specs.push_back(QPDFJob::PageSpec(file, this->pages_password, range));
    this->accumulated_args.clear();
    this->pages_password = nullptr;
    if (next_file != nullptr)
    {
        this->accumulated_args.push_back(next_file);
    }
}

void
ArgParser::argEndPages()
{
    argPagesPositional(nullptr);
    if (o.page_specs.empty())
    {
        usage("--pages: no page specifications given");
    }
}

void
ArgParser::argUnderlay()
{
    parseUnderOverlayOptions(&o.underlay);
}

void
ArgParser::argOverlay()
{
    parseUnderOverlayOptions(&o.overlay);
}

void
ArgParser::argRotate(char* parameter)
{
    parseRotationParameter(parameter);
}

void
ArgParser::argFlattenRotation()
{
    o.flatten_rotation = true;
}

void
ArgParser::argListAttachments()
{
    o.list_attachments = true;
    o.require_outfile = false;
}

void
ArgParser::argShowAttachment(char* parameter)
{
    o.attachment_to_show = parameter;
    o.require_outfile = false;
}

void
ArgParser::argRemoveAttachment(char* parameter)
{
    o.attachments_to_remove.push_back(parameter);
}

void
ArgParser::argAddAttachment()
{
    o.attachments_to_add.push_back(QPDFJob::AddAttachment());
    this->ap.selectOptionTable(O_ATTACHMENT);
}

void
ArgParser::argCopyAttachments()
{
    o.attachments_to_copy.push_back(QPDFJob::CopyAttachmentFrom());
    this->ap.selectOptionTable(O_COPY_ATTACHMENT);
}

void
ArgParser::argStreamData(char* parameter)
{
    o.stream_data_set = true;
    if (strcmp(parameter, "compress") == 0)
    {
        o.stream_data_mode = qpdf_s_compress;
    }
    else if (strcmp(parameter, "preserve") == 0)
    {
        o.stream_data_mode = qpdf_s_preserve;
    }
    else if (strcmp(parameter, "uncompress") == 0)
    {
        o.stream_data_mode = qpdf_s_uncompress;
    }
    else
    {
        // If this happens, it means streamDataChoices in
        // ArgParser::initOptionTable is wrong.
        usage("invalid stream-data option");
    }
}

void
ArgParser::argCompressStreams(char* parameter)
{
    o.compress_streams_set = true;
    o.compress_streams = (strcmp(parameter, "y") == 0);
}

void
ArgParser::argRecompressFlate()
{
    o.recompress_flate_set = true;
    o.recompress_flate = true;
}

void
ArgParser::argCompressionLevel(char* parameter)
{
    o.compression_level = QUtil::string_to_int(parameter);
}

void
ArgParser::argDecodeLevel(char* parameter)
{
    o.decode_level_set = true;
    if (strcmp(parameter, "none") == 0)
    {
        o.decode_level = qpdf_dl_none;
    }
    else if (strcmp(parameter, "generalized") == 0)
    {
        o.decode_level = qpdf_dl_generalized;
    }
    else if (strcmp(parameter, "specialized") == 0)
    {
        o.decode_level = qpdf_dl_specialized;
    }
    else if (strcmp(parameter, "all") == 0)
    {
        o.decode_level = qpdf_dl_all;
    }
    else
    {
        // If this happens, it means decodeLevelChoices in
        // ArgParser::initOptionTable is wrong.
        usage("invalid option");
    }
}

void
ArgParser::argNormalizeContent(char* parameter)
{
    o.normalize_set = true;
    o.normalize = (strcmp(parameter, "y") == 0);
}

void
ArgParser::argSuppressRecovery()
{
    o.suppress_recovery = true;
}

void
ArgParser::argObjectStreams(char* parameter)
{
    o.object_stream_set = true;
    if (strcmp(parameter, "disable") == 0)
    {
        o.object_stream_mode = qpdf_o_disable;
    }
    else if (strcmp(parameter, "preserve") == 0)
    {
        o.object_stream_mode = qpdf_o_preserve;
    }
    else if (strcmp(parameter, "generate") == 0)
    {
        o.object_stream_mode = qpdf_o_generate;
    }
    else
    {
        // If this happens, it means objectStreamsChoices in
        // ArgParser::initOptionTable is wrong.
        usage("invalid object stream mode");
    }
}

void
ArgParser::argIgnoreXrefStreams()
{
    o.ignore_xref_streams = true;
}

void
ArgParser::argQdf()
{
    o.qdf_mode = true;
}

void
ArgParser::argPreserveUnreferenced()
{
    o.preserve_unreferenced_objects = true;
}

void
ArgParser::argPreserveUnreferencedResources()
{
    o.remove_unreferenced_page_resources = QPDFJob::re_no;
}

void
ArgParser::argRemoveUnreferencedResources(char* parameter)
{
    if (strcmp(parameter, "auto") == 0)
    {
        o.remove_unreferenced_page_resources = QPDFJob::re_auto;
    }
    else if (strcmp(parameter, "yes") == 0)
    {
        o.remove_unreferenced_page_resources = QPDFJob::re_yes;
    }
    else if (strcmp(parameter, "no") == 0)
    {
        o.remove_unreferenced_page_resources = QPDFJob::re_no;
    }
    else
    {
        // If this happens, it means remove_unref_choices in
        // ArgParser::initOptionTable is wrong.
        usage("invalid value for --remove-unreferenced-page-resources");
    }
}

void
ArgParser::argKeepFilesOpen(char* parameter)
{
    o.keep_files_open_set = true;
    o.keep_files_open = (strcmp(parameter, "y") == 0);
}

void
ArgParser::argKeepFilesOpenThreshold(char* parameter)
{
    o.keep_files_open_threshold = QUtil::string_to_uint(parameter);
}

void
ArgParser::argNewlineBeforeEndstream()
{
    o.newline_before_endstream = true;
}

void
ArgParser::argLinearizePass1(char* parameter)
{
    o.linearize_pass1 = parameter;
}

void
ArgParser::argCoalesceContents()
{
    o.coalesce_contents = true;
}

void
ArgParser::argFlattenAnnotations(char* parameter)
{
    o.flatten_annotations = true;
    if (strcmp(parameter, "screen") == 0)
    {
        o.flatten_annotations_forbidden |= an_no_view;
    }
    else if (strcmp(parameter, "print") == 0)
    {
        o.flatten_annotations_required |= an_print;
    }
}

void
ArgParser::argGenerateAppearances()
{
    o.generate_appearances = true;
}

void
ArgParser::argMinVersion(char* parameter)
{
    o.min_version = parameter;
}

void
ArgParser::argForceVersion(char* parameter)
{
    o.force_version = parameter;
}

void
ArgParser::argSplitPages(char* parameter)
{
    int n = ((parameter == 0) ? 1 :
             QUtil::string_to_int(parameter));
    o.split_pages = n;
}

void
ArgParser::argVerbose()
{
    o.verbose = true;
}

void
ArgParser::argProgress()
{
    o.progress = true;
}

void
ArgParser::argNoWarn()
{
    o.suppress_warnings = true;
}

void
ArgParser::argWarningExitZero()
{
    o.warnings_exit_zero = true;
}

void
ArgParser::argDeterministicId()
{
    o.deterministic_id = true;
}

void
ArgParser::argStaticId()
{
    o.static_id = true;
}

void
ArgParser::argStaticAesIv()
{
    o.static_aes_iv = true;
}

void
ArgParser::argNoOriginalObjectIds()
{
    o.suppress_original_object_id = true;
}

void
ArgParser::argShowEncryption()
{
    o.show_encryption = true;
    o.require_outfile = false;
}

void
ArgParser::argShowEncryptionKey()
{
    o.show_encryption_key = true;
}

void
ArgParser::argCheckLinearization()
{
    o.check_linearization = true;
    o.require_outfile = false;
}

void
ArgParser::argShowLinearization()
{
    o.show_linearization = true;
    o.require_outfile = false;
}

void
ArgParser::argShowXref()
{
    o.show_xref = true;
    o.require_outfile = false;
}

void
ArgParser::argShowObject(char* parameter)
{
    QPDFJob::parse_object_id(parameter, o.show_trailer, o.show_obj, o.show_gen);
    o.require_outfile = false;
}

void
ArgParser::argRawStreamData()
{
    o.show_raw_stream_data = true;
}

void
ArgParser::argFilteredStreamData()
{
    o.show_filtered_stream_data = true;
}

void
ArgParser::argShowNpages()
{
    o.show_npages = true;
    o.require_outfile = false;
}

void
ArgParser::argShowPages()
{
    o.show_pages = true;
    o.require_outfile = false;
}

void
ArgParser::argWithImages()
{
    o.show_page_images = true;
}

void
ArgParser::argJson()
{
    o.json = true;
    o.require_outfile = false;
}

void
ArgParser::argJsonKey(char* parameter)
{
    o.json_keys.insert(parameter);
}

void
ArgParser::argJsonObject(char* parameter)
{
    o.json_objects.insert(parameter);
}

void
ArgParser::argCheck()
{
    o.check = true;
    o.require_outfile = false;
}

void
ArgParser::argOptimizeImages()
{
    o.optimize_images = true;
}

void
ArgParser::argExternalizeInlineImages()
{
    o.externalize_inline_images = true;
}

void
ArgParser::argKeepInlineImages()
{
    o.keep_inline_images = true;
}

void
ArgParser::argRemovePageLabels()
{
    o.remove_page_labels = true;
}

void
ArgParser::argOiMinWidth(char* parameter)
{
    o.oi_min_width = QUtil::string_to_uint(parameter);
}

void
ArgParser::argOiMinHeight(char* parameter)
{
    o.oi_min_height = QUtil::string_to_uint(parameter);
}

void
ArgParser::argOiMinArea(char* parameter)
{
    o.oi_min_area = QUtil::string_to_uint(parameter);
}

void
ArgParser::argIiMinBytes(char* parameter)
{
    o.ii_min_bytes = QUtil::string_to_uint(parameter);
}

void
ArgParser::arg40Print(char* parameter)
{
    o.r2_print = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg40Modify(char* parameter)
{
    o.r2_modify = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg40Extract(char* parameter)
{
    o.r2_extract = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg40Annotate(char* parameter)
{
    o.r2_annotate = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128Accessibility(char* parameter)
{
    o.r3_accessibility = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128Extract(char* parameter)
{
    o.r3_extract = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128Print(char* parameter)
{
    if (strcmp(parameter, "full") == 0)
    {
        o.r3_print = qpdf_r3p_full;
    }
    else if (strcmp(parameter, "low") == 0)
    {
        o.r3_print = qpdf_r3p_low;
    }
    else if (strcmp(parameter, "none") == 0)
    {
        o.r3_print = qpdf_r3p_none;
    }
    else
    {
        usage("invalid print option");
    }
}

void
ArgParser::arg128Modify(char* parameter)
{
    if (strcmp(parameter, "all") == 0)
    {
        o.r3_assemble = true;
        o.r3_annotate_and_form = true;
        o.r3_form_filling = true;
        o.r3_modify_other = true;
    }
    else if (strcmp(parameter, "annotate") == 0)
    {
        o.r3_assemble = true;
        o.r3_annotate_and_form = true;
        o.r3_form_filling = true;
        o.r3_modify_other = false;
    }
    else if (strcmp(parameter, "form") == 0)
    {
        o.r3_assemble = true;
        o.r3_annotate_and_form = false;
        o.r3_form_filling = true;
        o.r3_modify_other = false;
    }
    else if (strcmp(parameter, "assembly") == 0)
    {
        o.r3_assemble = true;
        o.r3_annotate_and_form = false;
        o.r3_form_filling = false;
        o.r3_modify_other = false;
    }
    else if (strcmp(parameter, "none") == 0)
    {
        o.r3_assemble = false;
        o.r3_annotate_and_form = false;
        o.r3_form_filling = false;
        o.r3_modify_other = false;
    }
    else
    {
        usage("invalid modify option");
    }
}

void
ArgParser::arg128ClearTextMetadata()
{
    o.cleartext_metadata = true;
}

void
ArgParser::arg128Assemble(char* parameter)
{
    o.r3_assemble = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128Annotate(char* parameter)
{
    o.r3_annotate_and_form = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128Form(char* parameter)
{
    o.r3_form_filling = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128ModOther(char* parameter)
{
    o.r3_modify_other = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128UseAes(char* parameter)
{
    o.use_aes = (strcmp(parameter, "y") == 0);
}

void
ArgParser::arg128ForceV4()
{
    o.force_V4 = true;
}

void
ArgParser::arg256ForceR5()
{
    o.force_R5 = true;
}

void
ArgParser::argEndEncrypt()
{
    o.encrypt = true;
    o.decrypt = false;
    o.copy_encryption = false;
}

void
ArgParser::argUOpositional(char* arg)
{
    if (o.under_overlay->filename)
    {
        usage(o.under_overlay->which + " file already specified");
    }
    else
    {
        o.under_overlay->filename = arg;
    }
}

void
ArgParser::argUOto(char* parameter)
{
    parseNumrange(parameter, 0);
    o.under_overlay->to_nr = parameter;
}

void
ArgParser::argUOfrom(char* parameter)
{
    if (strlen(parameter))
    {
        parseNumrange(parameter, 0);
    }
    o.under_overlay->from_nr = parameter;
}

void
ArgParser::argUOrepeat(char* parameter)
{
    if (strlen(parameter))
    {
        parseNumrange(parameter, 0);
    }
    o.under_overlay->repeat_nr = parameter;
}

void
ArgParser::argUOpassword(char* parameter)
{
    o.under_overlay->password = parameter;
}

void
ArgParser::argEndUnderOverlay()
{
    if (0 == o.under_overlay->filename)
    {
        usage(o.under_overlay->which + " file not specified");
    }
    o.under_overlay = 0;
}

void
ArgParser::argReplaceInput()
{
    o.replace_input = true;
}

void
ArgParser::argIsEncrypted()
{
    o.check_is_encrypted = true;
    o.require_outfile = false;
}

void
ArgParser::argRequiresPassword()
{
    o.check_requires_password = true;
    o.require_outfile = false;
}

void
ArgParser::argAApositional(char* arg)
{
    o.attachments_to_add.back().path = arg;
}

void
ArgParser::argAAKey(char* parameter)
{
    o.attachments_to_add.back().key = parameter;
}

void
ArgParser::argAAFilename(char* parameter)
{
    o.attachments_to_add.back().filename = parameter;
}

void
ArgParser::argAACreationDate(char* parameter)
{
    if (! QUtil::pdf_time_to_qpdf_time(parameter))
    {
        usage(std::string(parameter) + " is not a valid PDF timestamp");
    }
    o.attachments_to_add.back().creationdate = parameter;
}

void
ArgParser::argAAModDate(char* parameter)
{
    if (! QUtil::pdf_time_to_qpdf_time(parameter))
    {
        usage(std::string(parameter) + " is not a valid PDF timestamp");
    }
    o.attachments_to_add.back().moddate = parameter;
}

void
ArgParser::argAAMimeType(char* parameter)
{
    if (strchr(parameter, '/') == nullptr)
    {
        usage("mime type should be specified as type/subtype");
    }
    o.attachments_to_add.back().mimetype = parameter;
}

void
ArgParser::argAADescription(char* parameter)
{
    o.attachments_to_add.back().description = parameter;
}

void
ArgParser::argAAReplace()
{
    o.attachments_to_add.back().replace = true;
}

void
ArgParser::argEndAddAttachment()
{
    static std::string now = QUtil::qpdf_time_to_pdf_time(
        QUtil::get_current_qpdf_time());
    auto& cur = o.attachments_to_add.back();
    if (cur.path.empty())
    {
        usage("add attachment: no path specified");
    }
    std::string last_element = QUtil::path_basename(cur.path);
    if (last_element.empty())
    {
        usage("path for --add-attachment may not be empty");
    }
    if (cur.filename.empty())
    {
        cur.filename = last_element;
    }
    if (cur.key.empty())
    {
        cur.key = last_element;
    }
    if (cur.creationdate.empty())
    {
        cur.creationdate = now;
    }
    if (cur.moddate.empty())
    {
        cur.moddate = now;
    }
}

void
ArgParser::argCApositional(char* arg)
{
    o.attachments_to_copy.back().path = arg;
}

void
ArgParser::argCAprefix(char* parameter)
{
    o.attachments_to_copy.back().prefix = parameter;
}

void
ArgParser::argCApassword(char* parameter)
{
    o.attachments_to_copy.back().password = parameter;
}

void
ArgParser::argEndCopyAttachments()
{
    if (o.attachments_to_copy.back().path.empty())
    {
        usage("copy attachments: no path specified");
    }
}

void
ArgParser::usage(std::string const& message)
{
    if (this->ap.isCompleting())
    {
        // This will cause bash to fall back to regular file completion.
        exit(0);
    }
    else
    {
        throw QPDFArgParser::Usage(message);
    }
}

std::vector<int>
ArgParser::parseNumrange(char const* range, int max, bool throw_error)
{
    try
    {
        return QUtil::parse_numrange(range, max);
    }
    catch (std::runtime_error& e)
    {
        if (throw_error)
        {
            throw(e);
        }
        else
        {
            usage(e.what());
        }
    }
    return std::vector<int>();
}

void
ArgParser::parseUnderOverlayOptions(QPDFJob::UnderOverlay* uo)
{
    o.under_overlay = uo;
    this->ap.selectOptionTable(O_UNDER_OVERLAY);
}

void
ArgParser::parseRotationParameter(std::string const& parameter)
{
    std::string angle_str;
    std::string range;
    size_t colon = parameter.find(':');
    int relative = 0;
    if (colon != std::string::npos)
    {
        if (colon > 0)
        {
            angle_str = parameter.substr(0, colon);
        }
        if (colon + 1 < parameter.length())
        {
            range = parameter.substr(colon + 1);
        }
    }
    else
    {
        angle_str = parameter;
    }
    if (angle_str.length() > 0)
    {
        char first = angle_str.at(0);
        if ((first == '+') || (first == '-'))
        {
            relative = ((first == '+') ? 1 : -1);
            angle_str = angle_str.substr(1);
        }
        else if (! QUtil::is_digit(angle_str.at(0)))
        {
            angle_str = "";
        }
    }
    if (range.empty())
    {
        range = "1-z";
    }
    bool range_valid = false;
    try
    {
        parseNumrange(range.c_str(), 0, true);
        range_valid = true;
    }
    catch (std::runtime_error const&)
    {
        // ignore
    }
    if (range_valid &&
        ((angle_str == "0") ||(angle_str == "90") ||
         (angle_str == "180") || (angle_str == "270")))
    {
        int angle = QUtil::string_to_int(angle_str.c_str());
        if (relative == -1)
        {
            angle = -angle;
        }
        o.rotations[range] = QPDFJob::RotationSpec(angle, (relative != 0));
    }
    else
    {
        usage("invalid parameter to rotate: " + parameter);
    }
}

void
ArgParser::parseOptions()
{
    try
    {
        this->ap.parseArgs();
    }
    catch (QPDFArgParser::Usage& e)
    {
        usage(e.what());
    }
}

void
ArgParser::doFinalChecks()
{
    if (o.replace_input)
    {
        if (o.outfilename)
        {
            usage("--replace-input may not be used when"
                  " an output file is specified");
        }
        else if (o.split_pages)
        {
            usage("--split-pages may not be used with --replace-input");
        }
    }
    if (o.infilename == 0)
    {
        usage("an input file name is required");
    }
    else if (o.require_outfile && (o.outfilename == 0) && (! o.replace_input))
    {
        usage("an output file name is required; use - for standard output");
    }
    else if ((! o.require_outfile) &&
             ((o.outfilename != 0) || o.replace_input))
    {
        usage("no output file may be given for this option");
    }
    if (o.check_requires_password && o.check_is_encrypted)
    {
        usage("--requires-password and --is-encrypted may not be given"
              " together");
    }

    if (o.encrypt && (! o.allow_insecure) &&
        (o.owner_password.empty() &&
         (! o.user_password.empty()) &&
         (o.keylen == 256)))
    {
        // Note that empty owner passwords for R < 5 are copied from
        // the user password, so this lack of security is not an issue
        // for those files. Also we are consider only the ability to
        // open the file without a password to be insecure. We are not
        // concerned about whether the viewer enforces security
        // settings when the user and owner password match.
        usage("A PDF with a non-empty user password and an empty owner"
              " password encrypted with a 256-bit key is insecure as it"
              " can be opened without a password. If you really want to"
              " do this, you must also give the --allow-insecure option"
              " before the -- that follows --encrypt.");
    }

    if (o.require_outfile && o.outfilename &&
        (strcmp(o.outfilename, "-") == 0))
    {
        if (o.split_pages)
        {
            usage("--split-pages may not be used when"
                  " writing to standard output");
        }
        if (o.verbose)
        {
            usage("--verbose may not be used when"
                  " writing to standard output");
        }
        if (o.progress)
        {
            usage("--progress may not be used when"
                  " writing to standard output");
        }
    }

    if ((! o.split_pages) && QUtil::same_file(o.infilename, o.outfilename))
    {
        QTC::TC("qpdf", "qpdf same file error");
        usage("input file and output file are the same;"
              " use --replace-input to intentionally overwrite the input file");
    }
}

void
QPDFJob::initializeFromArgv(int argc, char* argv[], char const* progname_env)
{
    if (progname_env == nullptr)
    {
        progname_env = "QPDF_EXECUTABLE";
    }
    // QPDFArgParser must stay in scope for the life of the QPDFJob
    // object since it holds dynamic memory used for argv, which is
    // pointed to by other member variables.
    this->m->ap = new QPDFArgParser(argc, argv, progname_env);
    setMessagePrefix(this->m->ap->getProgname());
    ArgParser ap(*this->m->ap, *this);
    ap.parseOptions();
}