parse_arguments.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <optional>
#include <filesystem>
#include <memory>
#include <unistd.h>
 
#include <include/BashVersion.h>
#include <include/xgetopt.h>
 
#include <version.h>
#include <updated_year.h>
 
constexpr const char* program_name = "Bash++";
 
constexpr const char* copyright = "Copyright (C) 2024-"
    bpp_compiler_updated_year
    " Andrew S. Rightenburg\n\n"
    "This program is free software; you can redistribute it and/or modify\n"
    "it under the terms of the GNU General Public License as published by\n"
    "the Free Software Foundation; either version 3 of the License, or\n"
    "(at your option) any later version.\n\n"
    "This program is distributed in the hope that it will be useful,\n"
    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    "GNU General Public License for more details.\n\n"
    "You should have received a copy of the GNU General Public License\n"
    "along with this program. If not, see http://www.gnu.org/licenses/.\n";
 
constexpr const char* help_intro = 
    "Usage: bpp [options] [file] ...\n"
    "If no file is specified, read from stdin\n"
    "All arguments after the file are passed to the compiled program\n"
    "Options:\n";
 
constexpr XGetOpt::OptionParser<
    XGetOpt::Option<'o', "output", "Specify output file (default: run on exit)", XGetOpt::RequiredArgument, "file">,
    XGetOpt::Option<'b', "target-bash", "Compile to Bash version (default: 5.2)", XGetOpt::RequiredArgument, "version">,
    XGetOpt::Option<'s', "no-warnings", "Suppress warnings", XGetOpt::NoArgument>,
    XGetOpt::Option<'I', "include", "Add directory to include path", XGetOpt::RequiredArgument, "directory">,
    XGetOpt::Option<'t', "tokens", "Display tokens from lexer (do not compile program)", XGetOpt::NoArgument>,
    XGetOpt::Option<'p', "parse-tree", "Display parse tree (do not compile program)", XGetOpt::NoArgument>,
    XGetOpt::Option<'v', "version", "Display version information and exit", XGetOpt::NoArgument>,
    XGetOpt::Option<'h', "help", "Display this help message and exit", XGetOpt::NoArgument>
> OptionParser;
 
class Arguments {
    private:
        std::vector<char*>                        m_program_arguments;
        std::optional<std::string>                m_input_file;
        std::optional<std::string>                m_output_file;
        BashVersion                               m_target_bash_version = {5, 2}; // Default to Bash 5.2
        std::shared_ptr<std::vector<std::string>> m_include_paths = std::make_shared<std::vector<std::string>>();
        bool f_suppress_warnings = false;
        bool f_display_tokens = false;
        bool f_display_parse_tree = false;
        bool f_run_on_exit = true;
        bool f_exit_early = false; // Exit early if the request is just -h/--help or -v/--version
 
    public:
        void set_program_arguments(int argc, char** argv) {
            auto arguments_span = std::span<char*>{argv, static_cast<size_t>(argc)};
            this->m_program_arguments = std::vector<char*>(arguments_span.begin(), arguments_span.end());
        }
        const std::vector<char*>& program_arguments() const {
            return this->m_program_arguments;
        }
 
        void set_input_file(std::string_view input_file) {
            // Verify that the file exists and is a regular file
            if (!std::filesystem::exists(input_file)) {
                throw std::runtime_error("Source file '" + std::string(input_file) + "' does not exist");
            }
            if (!std::filesystem::is_regular_file(input_file)) {
                throw std::runtime_error("Source file '" + std::string(input_file) + "' is not a regular file");
            }
            this->m_input_file = input_file;
        }
        const std::optional<std::string>& input_file() const {
            return this->m_input_file;
        }
 
        void set_output_file(std::string_view output_file_arg) {
            if (output_file_arg == "-") {
                this->m_output_file = output_file_arg;
                return;
            }
 
            std::string parsed_output_file;
 
            {
                std::filesystem::path output_path(output_file_arg);
                if (output_path.is_absolute()) {
                    parsed_output_file = output_path.string();
                } else {
                    parsed_output_file = std::filesystem::current_path() / output_path;
                }
            }
 
            // Check if we have permission to write to the specified output file
            // If the file exists, verify write access; if it doesn't, verify write access on its parent directory
            try {
                if (std::filesystem::exists(parsed_output_file)) {
                    if (access(parsed_output_file.c_str(), W_OK) != 0) {
                        throw std::runtime_error("No write permission for output file '" + parsed_output_file + "'");
                    }
                } else {
                    std::filesystem::path parent_path = std::filesystem::path(parsed_output_file).parent_path();
                    if (!std::filesystem::exists(parent_path) || !std::filesystem::is_directory(parent_path)) {
                        throw std::runtime_error("Parent directory of output file '" + parsed_output_file + "' does not exist or is not a directory");
                    }
                    if (access(parent_path.c_str(), W_OK) != 0) {
                        throw std::runtime_error("No write permission for parent directory of output file '" + parsed_output_file + "'");
                    }
                }
            } catch (const std::exception& e) {
                throw std::runtime_error(std::string("Could not verify write permission for output file '") + parsed_output_file + "': " + e.what());
            }
 
            this->m_output_file = parsed_output_file;
        }
        const std::optional<std::string>& output_file() const {
            return this->m_output_file;
        }
 
        void set_target_bash_version(std::string_view version_arg) {
            this->m_target_bash_version = BashVersion(version_arg);
        }
        const BashVersion& target_bash_version() const {
            return this->m_target_bash_version;
        }
 
        void add_include_path(std::string_view path) {
            if (!std::filesystem::is_directory(path)) {
                throw std::runtime_error("Include path '" + std::string(path) + "' is not a directory");
            }
            this->m_include_paths->emplace_back(path);
        }
        const std::shared_ptr<std::vector<std::string>>& include_paths() const {
            return this->m_include_paths;
        }
        
        void set_suppress_warnings(bool suppress) {
            this->f_suppress_warnings = suppress;
        }
        bool suppress_warnings() const {
            return this->f_suppress_warnings;
        }
 
        void set_display_tokens(bool display) {
            this->f_display_tokens = display;
        }
        bool display_tokens() const {
            return this->f_display_tokens;
        }
 
        void set_display_parse_tree(bool display) {
            this->f_display_parse_tree = display;
        }
        bool display_parse_tree() const {
            return this->f_display_parse_tree;
        }
 
        void set_exit_early(bool exit) {
            this->f_exit_early = exit;
        }
        bool exit_early() const {
            return this->f_exit_early;
        }
 
        void set_run_on_exit(bool run_on_exit) {
            this->f_run_on_exit = run_on_exit;
        }
        bool run_on_exit() const {
            return this->f_run_on_exit;
        }
 
        bool output_to_stdout() const {
            return this->m_output_file == "-";
        }
 
        bool output_to_file() const {
            return this->m_output_file.has_value() && this->m_output_file.value() != "-";
        }
 
        bool input_from_stdin() const {
            return !this->m_input_file.has_value();
        }
};
 
inline Arguments parse_arguments(int argc, char* argv[]) {
    Arguments args;
 
    // Will throw if invalid arguments are provided
    auto [compiler_arguments, program_arguments]
        = OptionParser.parse_until<XGetOpt::StopCondition::AfterFirstNonOptionArgument>(argc, argv);
 
    args.set_program_arguments(program_arguments.argc, program_arguments.argv);
 
    if (compiler_arguments.getNonOptionArguments().size() > 0) {
        args.set_input_file(compiler_arguments.getNonOptionArguments()[0]);
    }
 
    for (const auto& arg : compiler_arguments) {
        switch (arg.getShortOpt()) {
            default:
                // This should never happen since XGetOpt should throw on unrecognized options
                std::cerr << program_name << ": Warning: Unhandled option '" << static_cast<char>(arg.getShortOpt()) << "'" << std::endl;
                break;
            case 'b':
                args.set_target_bash_version(arg.getArgument());
                break;
            case 'h':
                std::cout << program_name << " " << bpp_compiler_version << std::endl
                    << help_intro << OptionParser.getHelpString();
                args.set_exit_early(true);
                return args;
                break;
            case 'I':
                args.add_include_path(arg.getArgument());
                break;
            case 'o':
                args.set_run_on_exit(false);
                args.set_output_file(arg.getArgument());
                break;
            case 'p':
                args.set_display_parse_tree(true);
                break;
            case 's':
                args.set_suppress_warnings(true);
                break;
            case 't':
                args.set_display_tokens(true);
                break;
            case 'v':
                std::cout << program_name << " " << bpp_compiler_version << std::endl << copyright;
                args.set_exit_early(true);
                return args;
                break;
        }
    }
 
    return args;
}