line_tools.hpp

Go to the documentation of this file.

/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2024 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/
 
 
#ifndef LINE_TOOLS_HPP
#define LINE_TOOLS_HPP
 
#include "../my_config.h"
 
#include <string>
#include <vector>
#include <deque>
#include <memory>
#include "libdar.hpp"
#include "tlv_list.hpp"
#include "tools.hpp"
 
using namespace libdar;
 
 
constexpr U_I LINE_TOOLS_SI_SUFFIX = 1000;
constexpr U_I LINE_TOOLS_BIN_SUFFIX = 1024;
 
class argc_argv
{
public:
    argc_argv(S_I size = 0);
    argc_argv(const argc_argv & ref) { throw Efeature("argc_argv"); };
    argc_argv & operator = (const argc_argv & ref) { throw Efeature("argc_argv"); };
    ~argc_argv() noexcept(false);
 
    void resize(S_I size);
    void set_arg(const std::string & arg, S_I index);
    void set_arg(generic_file & f, U_I size, S_I index);
 
    S_I argc() const { return x_argc; };
    char* const * argv() const { return x_argv; }; // well, the const method is a bit silly, as the caller has the possibility to modify what is pointed to by the returned value...
 
private:
    S_I x_argc;
    char **x_argv;
};
 
extern void line_tools_slice_ownership(const std::string & cmd, std::string & slice_permission, std::string & slice_user_ownership, std::string & slice_group_ownership);
extern void line_tools_repeat_param(const std::string & cmd, infinint & repeat_count, infinint & repeat_byte);
extern void line_tools_tlv_list2argv(user_interaction & dialog, tlv_list & list, argc_argv & arg);
 
extern S_I line_tools_reset_getopt();
 
 
std::string::const_iterator line_tools_find_first_char_out_of_parenth(const std::string & argument, unsigned char to_find);
std::string::const_iterator line_tools_find_last_char_out_of_parenth(const std::string & argument, unsigned char to_find);
 
std::string line_tools_expand_user_comment(const std::string & user_comment, S_I argc, char *const argv[]);
 
std::deque<std::string> line_tools_explode_PATH(const char *the_path);
 
std::string line_tools_get_full_path_from_PATH(const std::deque<std::string> & the_path, const char * filename);
 
void line_tools_split_at_first_space(const char *field, std::string & before_space, std::string & after_space);
 
void line_tools_get_min_digits(std::string arg, infinint & num, infinint & ref_num, infinint & aux_num);
 
 
#if HAVE_GETOPT_LONG
#endif
extern void line_tools_look_for(const std::deque<char> & arguments,
                S_I argc,
                char *const argv[],
                const char *getopt_string,
#if HAVE_GETOPT_LONG
                const struct option *long_options,
#endif
                char stop_scan,
                std::deque<char> & presence);
 
 
 
#if HAVE_GETOPT_LONG
#endif
extern void line_tools_look_for_Q(S_I argc,
                   char *const argv[],
                   const char *getopt_string,
#if HAVE_GETOPT_LONG
                   const struct option *long_options,
#endif
                   char stop_scan,
                   bool & Q_is_present);
 
 
 
template <class T> void line_tools_split(const std::string & val, char sep, T & split)
{
    std::string::const_iterator be = val.begin();
    std::string::const_iterator ne = val.begin();
    split.clear();
 
    while(ne != val.end())
    {
    if(*ne != sep)
        ++ne;
    else
    {
        split.push_back(std::string(be, ne));
        ++ne;
        be = ne;
    }
    }
 
    if(be != val.end())
    split.push_back(std::string(be, ne));
}
 
extern std::set<std::string> line_tools_deque_to_set(const std::deque<std::string> & list);
 
extern void line_tools_4_4_build_compatible_overwriting_policy(bool allow_over,
                                   bool detruire,
                                   bool more_recent,
                                   const libdar::infinint & hourshift,
                                   bool ea_erase,
                                   const libdar::crit_action * & overwrite);
 
extern void line_tools_crypto_split_algo_pass(const secu_string & all,
                          crypto_algo & algo,
                          secu_string & pass,
                          bool & no_cipher_given,
                          std::vector<std::string> & recipients);
 
extern void line_tools_display_signatories(user_interaction & ui, const std::list<signator> & gnupg_signed);
 
 
extern void line_tools_read_from_pipe(std::shared_ptr<user_interaction> & dialog, S_I fd, tlv_list & result);
 
 
extern void line_tools_extract_basename(const char *command_name, std::string & basename);
 
 
extern std::string::iterator line_tools_find_first_char_of(std::string &s, unsigned char v);
 
 
extern void line_tools_split_path_basename(const char *all, path * &chemin, std::string & base);
 
 
extern void line_tools_split_path_basename(const std::string &all, std::string & chemin, std::string & base);
 
 
extern bool line_tools_split_entrepot_path(const std::string &all,
                       std::string & proto,
                       std::string & login,
                       secu_string & password,
                       std::string & hostname,
                       std::string & port,
                       std::string & path_basename);
 
 
extern S_I line_tools_str2signed_int(const std::string & x);
 
 
extern infinint line_tools_convert_date(const std::string & repres);
 
 
extern void line_tools_display_features(user_interaction & dialog);
 
 
extern const char *line_tools_get_from_env(const char **env, const char *clef);
 
 
extern void line_tools_check_basename(user_interaction & dialog,
                      const path & loc,
                      std::string & base,
                      const std::string & extension,
                      bool create);
 
 
void line_tools_check_min_digits(user_interaction & dialog,
                 const path & loc,
                 const std::string & base,
                 const std::string & extension,
                 infinint & num_digits);
 
 
 
extern void line_tools_read_range(const std::string & s, S_I & min, U_I & max);
 
 
template <class T> void line_tools_split_in_words(generic_file & f, T & mots)
{
    std::deque <char> quotes;
    std::string current = "";
    char a;
    bool loop = true;
    bool escaped = false;
 
    mots.clear();
    while(loop)
    {
    if(f.read(&a, 1) != 1) // reached end of file
    {
        loop = false;
        a = ' '; // to close the last word
    }
 
    if(escaped)
    {
        current += a; // added without consideration of quoting of any sort
        escaped = false;
        continue; // continuing at beginning of the while loop
    }
    else
    {
        if(a == '\\')
        {
        escaped = true;
        continue; // continuing at beginning of the while loop
        }
    }
 
    if(quotes.empty()) // outside a word
        switch(a)
        {
        case ' ':
        case '\t':
        case '\n':
        case '\r':
        break;
        case '"':
        case '\'':
        case '`':
        quotes.push_back(a);
        break;
        default:
        quotes.push_back(' '); // the quote space means no quote
        current += a; // a new argument is starting
        break;
        }
    else // inside a word
        switch(a)
        {
        case '\t':
        if(quotes.back() != ' ')
        {
            // this is the end of the wor(l)d ;-)
            // ...once again... 1000, 1999, 2012, and the next ones to come...
            break;
        }
            // no break !
        case '\n':
        case '\r':
        a = ' '; // replace carriage return inside quoted string by a space
            // no break !
        case ' ':
        case '"':
        case '\'':
        case '`':
        if(a == quotes.back()) // "a" is an ending quote
        {
            quotes.pop_back();
            if(quotes.empty()) // reached end of word
            {
            mots.push_back(current);
            current = "";
            }
            else
            current += a;
        }
        else // "a" is a nested starting quote
        {
            if(a != ' ') // quote ' ' does not have ending quote
            quotes.push_back(a);
            current += a;
        }
        break;
        default:
        current += a;
        }
    }
    if(!quotes.empty())
    throw Erange("make_args_from_file", tools_printf(dar_gettext("Parse error: Unmatched `%c'"), quotes.back()));
}
 
 
 
 
template <class T> void line_tools_split_in_words(const std::string & arg, T & mots)
{
    memory_file mem;
 
    mem.write(arg.c_str(), arg.size());
    mem.skip(0);
    line_tools_split_in_words(mem, mots);
}
 
 
extern std::string line_tools_build_regex_for_exclude_mask(const std::string & prefix,
                               const std::string & relative_part);
 
extern std::string line_tools_get_euid();
 
extern std::string line_tools_get_egid();
 
extern std::string line_tools_get_hostname();
 
extern std::string line_tools_get_date_utc();
 
extern void line_tools_merge_to_deque(std::deque<std::string> & a, const  std::deque<std::string> & b);
 
extern std::deque<std::string> line_tools_substract_from_deque(const std::deque<std::string> & a, const std::deque<std::string> & b);
 
 
extern delta_sig_block_size::fs_function_t line_tools_string_to_sig_block_size_function(const std::string & funname);
 
extern void line_tools_split_compression_algo(const char *arg,     
                          U_I base,            
                          compression & algo,  
                          U_I & level,         
                          U_I & block_size     
    );
 
 
 
#endif