lnav/src/shlex.hh

254 lines
8.3 KiB
C++
Raw Normal View History

/**
* Copyright (c) 2015, Timothy Stack
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of Timothy Stack nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @file shlex.hh
*/
#ifndef LNAV_SHLEX_HH_H
#define LNAV_SHLEX_HH_H
2020-09-11 04:19:23 +00:00
#include <pwd.h>
#include <map>
#include <vector>
#include <string>
#include "base/opt_util.hh"
2019-05-08 12:30:59 +00:00
#include "pcrepp/pcrepp.hh"
2020-09-11 04:19:23 +00:00
enum class shlex_token_t {
ST_ERROR,
2015-12-25 20:03:44 +00:00
ST_WHITESPACE,
ST_ESCAPE,
ST_DOUBLE_QUOTE_START,
ST_DOUBLE_QUOTE_END,
ST_SINGLE_QUOTE_START,
ST_SINGLE_QUOTE_END,
ST_VARIABLE_REF,
ST_QUOTED_VARIABLE_REF,
2015-12-25 20:03:44 +00:00
ST_TILDE,
};
class scoped_resolver {
public:
scoped_resolver(std::initializer_list<std::map<std::string, std::string> *> l) {
this->sr_stack.insert(this->sr_stack.end(), l.begin(), l.end());
};
typedef std::map<std::string, std::string>::const_iterator const_iterator;
const_iterator find(const std::string &str) const {
const_iterator retval;
for (auto scope : this->sr_stack) {
if ((retval = scope->find(str)) != scope->end()) {
return retval;
}
}
return this->end();
};
const_iterator end() const {
return this->sr_stack.back()->end();
}
std::vector<const std::map<std::string, std::string> *> sr_stack;
};
class shlex {
public:
shlex(const char *str, size_t len)
: s_str(str),
2020-09-11 04:19:23 +00:00
s_len(len) {
};
explicit shlex(const string_fragment &sf)
: s_str(sf.data()), s_len(sf.length()) {
}
2020-09-11 04:19:23 +00:00
explicit shlex(const std::string &str)
: s_str(str.c_str()),
2020-09-11 04:19:23 +00:00
s_len(str.size()) {
};
shlex &with_ignore_quotes(bool val) {
this->s_ignore_quotes = val;
return *this;
}
2020-09-11 04:19:23 +00:00
bool tokenize(pcre_context::capture_t &cap_out, shlex_token_t &token_out);
template <typename Resolver = scoped_resolver>
bool eval(std::string &result, const Resolver &vars) {
result.clear();
pcre_context::capture_t cap;
shlex_token_t token;
int last_index = 0;
while (this->tokenize(cap, token)) {
result.append(&this->s_str[last_index], cap.c_begin - last_index);
switch (token) {
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_ERROR:
return false;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_ESCAPE:
result.append(1, this->s_str[cap.c_begin + 1]);
break;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_WHITESPACE:
2015-12-25 20:03:44 +00:00
result.append(&this->s_str[cap.c_begin], cap.length());
break;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_VARIABLE_REF:
case shlex_token_t::ST_QUOTED_VARIABLE_REF: {
int extra = token == shlex_token_t::ST_VARIABLE_REF ? 0 : 1;
std::string var_name(&this->s_str[cap.c_begin + 1 + extra], cap.length() - 1 - extra * 2);
std::map<std::string, std::string>::const_iterator local_var;
const char *var_value = getenv(var_name.c_str());
if ((local_var = vars.find(var_name)) != vars.end()) {
result.append(local_var->second);
}
2020-09-11 04:19:23 +00:00
else if (var_value != nullptr) {
result.append(var_value);
}
break;
}
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_TILDE:
this->resolve_home_dir(result, cap);
2015-12-25 20:03:44 +00:00
break;
default:
break;
}
last_index = cap.c_end;
}
result.append(&this->s_str[last_index], this->s_len - last_index);
return true;
};
template <typename Resolver>
bool split(std::vector<std::string> &result, const Resolver &vars) {
2015-12-25 20:03:44 +00:00
result.clear();
pcre_context::capture_t cap;
shlex_token_t token;
int last_index = 0;
bool start_new = true;
while (isspace(this->s_str[this->s_index])) {
this->s_index += 1;
}
while (this->tokenize(cap, token)) {
if (start_new) {
result.emplace_back("");
2015-12-25 20:03:44 +00:00
start_new = false;
}
result.back().append(&this->s_str[last_index], cap.c_begin - last_index);
switch (token) {
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_ERROR:
2015-12-25 20:03:44 +00:00
return false;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_ESCAPE:
2015-12-25 20:03:44 +00:00
result.back().append(1, this->s_str[cap.c_begin + 1]);
break;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_WHITESPACE:
2015-12-25 20:03:44 +00:00
start_new = true;
break;
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_VARIABLE_REF:
case shlex_token_t::ST_QUOTED_VARIABLE_REF: {
int extra = token == shlex_token_t::ST_VARIABLE_REF ? 0 : 1;
2015-12-25 20:03:44 +00:00
std::string var_name(&this->s_str[cap.c_begin + 1 + extra], cap.length() - 1 - extra * 2);
std::map<std::string, std::string>::const_iterator local_var;
const char *var_value = getenv(var_name.c_str());
if ((local_var = vars.find(var_name)) != vars.end()) {
result.back().append(local_var->second);
}
2020-09-11 04:19:23 +00:00
else if (var_value != nullptr) {
2015-12-25 20:03:44 +00:00
result.back().append(var_value);
}
break;
}
2020-09-11 04:19:23 +00:00
case shlex_token_t::ST_TILDE:
this->resolve_home_dir(result.back(), cap);
2015-12-25 20:03:44 +00:00
break;
default:
break;
}
last_index = cap.c_end;
}
if (last_index < this->s_len) {
if (start_new || result.empty()) {
2020-09-11 04:19:23 +00:00
result.emplace_back("");
2015-12-25 20:03:44 +00:00
}
result.back().append(&this->s_str[last_index], this->s_len - last_index);
}
return true;
}
void reset() {
this->s_index = 0;
2020-09-11 04:19:23 +00:00
this->s_state = state_t::STATE_NORMAL;
};
2020-09-11 04:19:23 +00:00
void scan_variable_ref(pcre_context::capture_t &cap_out, shlex_token_t &token_out);
2020-09-11 04:19:23 +00:00
void resolve_home_dir(std::string& result, const pcre_context::capture_t cap) const {
if (cap.length() == 1) {
result.append(getenv_opt("HOME").value_or("~"));
2020-09-11 04:19:23 +00:00
} else {
auto username = (char *) alloca(cap.length());
memcpy(username, &this->s_str[cap.c_begin + 1], cap.length() - 1);
username[cap.length() - 1] = '\0';
auto pw = getpwnam(username);
if (pw != nullptr) {
result.append(pw->pw_dir);
} else {
result.append(&this->s_str[cap.c_begin], cap.length());
}
}
2020-09-11 04:19:23 +00:00
}
2020-09-11 04:19:23 +00:00
enum class state_t {
STATE_NORMAL,
STATE_IN_DOUBLE_QUOTE,
STATE_IN_SINGLE_QUOTE,
};
const char *s_str;
2016-03-05 04:53:10 +00:00
ssize_t s_len;
2020-09-11 04:19:23 +00:00
bool s_ignore_quotes{false};
ssize_t s_index{0};
state_t s_state{state_t::STATE_NORMAL};
};
#endif //LNAV_SHLEX_HH_H