mirror of
https://github.com/matrix-construct/construct
synced 2024-12-01 19:22:53 +01:00
21aacf6509
This is available for a particular corner case due to our use of full- word format specifiers. Case: "%couch" is that %c followed by ouch, or is that the handled format specifier '%couch' ? If '%couch' is not registered there is no fallback to finding '%c' (maybe one day), so in this case one must write "%c$ouch" and '%c' becomes the specifier and the output for 'p' will be "pouch" and for "%c$$ouch" the output will be "p$ouch."
602 lines
15 KiB
C++
602 lines
15 KiB
C++
/**
|
|
* Copyright (C) 2016 Charybdis Development Team
|
|
* Copyright (C) 2016 Jason Volk <jason@zemos.net>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice is present in all copies.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
|
*/
|
|
|
|
#include <ircd/rfc1459_parse.h>
|
|
#include <ircd/rfc1459_gen.h>
|
|
#include <ircd/lex_cast.h>
|
|
#include <ircd/fmt.h>
|
|
|
|
BOOST_FUSION_ADAPT_STRUCT
|
|
(
|
|
ircd::fmt::spec,
|
|
( char, sign )
|
|
( int, width )
|
|
( std::string, name )
|
|
)
|
|
|
|
namespace ircd {
|
|
namespace fmt {
|
|
|
|
namespace qi = boost::spirit::qi;
|
|
namespace karma = boost::spirit::karma;
|
|
|
|
const char SPECIFIER
|
|
{
|
|
'%'
|
|
};
|
|
|
|
const char SPECIFIER_TERMINATOR
|
|
{
|
|
'$'
|
|
};
|
|
|
|
std::map<std::string, specifier *> _specifiers;
|
|
|
|
template<class generator> bool generate_string(char *&out, const generator &, const arg &);
|
|
template<class integer> bool generate_integer(char *&out, const size_t &max, const spec &, const integer &i);
|
|
|
|
struct nick_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const nick_specifier
|
|
{
|
|
"nick"s
|
|
};
|
|
|
|
struct user_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const user_specifier
|
|
{
|
|
"user"s
|
|
};
|
|
|
|
struct host_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const host_specifier
|
|
{
|
|
"host"s
|
|
};
|
|
|
|
struct string_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &val) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const string_specifier
|
|
{
|
|
"s"s
|
|
};
|
|
|
|
struct int_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &val) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const int_specifier
|
|
{
|
|
{ "d"s, "ld"s, "u"s, "lu"s, "zd"s, "zu"s }
|
|
};
|
|
|
|
struct char_specifier
|
|
:specifier
|
|
{
|
|
bool operator()(char *&out, const size_t &max, const spec &, const arg &val) const override;
|
|
using specifier::specifier;
|
|
}
|
|
const char_specifier
|
|
{
|
|
"c"s
|
|
};
|
|
|
|
bool is_specifier(const std::string &name);
|
|
void handle_specifier(char *&out, const size_t &max, const uint &idx, const spec &, const arg &);
|
|
|
|
namespace parse
|
|
{
|
|
using qi::lit;
|
|
using qi::char_;
|
|
using qi::int_;
|
|
using qi::eps;
|
|
using qi::repeat;
|
|
using qi::omit;
|
|
|
|
template<class it,
|
|
class top>
|
|
struct grammar
|
|
:qi::grammar<it, top>
|
|
{
|
|
qi::rule<it> specsym;
|
|
qi::rule<it> specterm;
|
|
qi::rule<it, std::string()> name;
|
|
qi::rule<it, fmt::spec> spec;
|
|
|
|
grammar(qi::rule<it, top> &top_rule);
|
|
};
|
|
}
|
|
|
|
} // namespace fmt
|
|
} // namespace ircd
|
|
|
|
using namespace ircd;
|
|
|
|
template<class it,
|
|
class top>
|
|
fmt::parse::grammar<it, top>::grammar(qi::rule<it, top> &top_rule)
|
|
:grammar<it, top>::base_type
|
|
{
|
|
top_rule
|
|
}
|
|
,specsym
|
|
{
|
|
lit(SPECIFIER)
|
|
}
|
|
,specterm
|
|
{
|
|
char_(SPECIFIER_TERMINATOR)
|
|
}
|
|
,name
|
|
{
|
|
repeat(1,14)[char_("A-Za-z")] >> omit[-specterm]
|
|
}
|
|
{
|
|
spec %= specsym >> -char_("+-") >> -int_ >> name[([]
|
|
(auto &str, auto &ctx, auto &valid)
|
|
{
|
|
valid = is_specifier(str);
|
|
})];
|
|
}
|
|
|
|
ssize_t
|
|
fmt::_snprintf(char *const &buf,
|
|
const size_t &max,
|
|
const char *const &fmt,
|
|
const ptrs &p,
|
|
const types &t)
|
|
try
|
|
{
|
|
if(unlikely(!max))
|
|
return 0;
|
|
|
|
char *out(buf); // Always points at next place to write
|
|
const char *stop(fmt); // Saves the 'last' place to copy a literal from
|
|
const char *start(strchr(fmt, SPECIFIER)); // The running position of the format string parse
|
|
const char *const end(fmt + strlen(fmt)); // The end of the format string
|
|
|
|
// Calculates remaining room in output buffer
|
|
const auto remaining([&max, &buf, &out]() -> size_t
|
|
{
|
|
return max - std::distance(buf, out) - 1;
|
|
});
|
|
|
|
// Copies string data between format specifiers.
|
|
const auto copy_literal([&stop, &out, &remaining]
|
|
(const char *const &end)
|
|
{
|
|
const size_t len(std::distance(stop, end));
|
|
const size_t &cpsz(std::min(len, remaining()));
|
|
memcpy(out, stop, cpsz);
|
|
out += cpsz;
|
|
});
|
|
|
|
size_t index(0); // The current position for vectors p and t (specifier count)
|
|
for(; start; stop = start++, start = start < end? strchr(start, SPECIFIER) : nullptr)
|
|
{
|
|
// Copy literal data from where the last parse stopped up to the found specifier
|
|
copy_literal(start);
|
|
|
|
// Instantiate the format specifier grammar
|
|
struct parser
|
|
:parse::grammar<const char *, fmt::spec>
|
|
{
|
|
parser(): grammar{grammar::spec} {}
|
|
}
|
|
static const parser;
|
|
|
|
// Parse the specifier with the grammar
|
|
fmt::spec spec;
|
|
if(!qi::parse(start, end, parser, spec))
|
|
continue;
|
|
|
|
// Throws if the format string has more specifiers than arguments.
|
|
const arg val{p.at(index), t.at(index)};
|
|
handle_specifier(out, remaining(), index, spec, val);
|
|
index++;
|
|
}
|
|
|
|
// If the end of the string is not a format specifier itself, it needs to be copied
|
|
if(!start)
|
|
copy_literal(end);
|
|
|
|
*out = '\0';
|
|
return std::distance(buf, out);
|
|
}
|
|
catch(const std::out_of_range &e)
|
|
{
|
|
throw invalid_format("Format string requires more than %zu arguments.", p.size());
|
|
}
|
|
|
|
const decltype(fmt::_specifiers) &
|
|
fmt::specifiers()
|
|
{
|
|
return _specifiers;
|
|
}
|
|
|
|
fmt::specifier::specifier(const std::string &name)
|
|
:specifier{{name}}
|
|
{
|
|
}
|
|
|
|
fmt::specifier::specifier(const std::initializer_list<std::string> &names)
|
|
:names{names}
|
|
{
|
|
for(const auto &name : this->names)
|
|
if(is_specifier(name))
|
|
throw error("Specifier '%c%s' already registered\n",
|
|
SPECIFIER,
|
|
name.c_str());
|
|
|
|
for(const auto &name : this->names)
|
|
_specifiers.emplace(name, this);
|
|
}
|
|
|
|
fmt::specifier::~specifier()
|
|
noexcept
|
|
{
|
|
for(const auto &name : names)
|
|
_specifiers.erase(name);
|
|
}
|
|
|
|
fmt::spec::spec()
|
|
:sign('+')
|
|
,width(0)
|
|
{
|
|
name.reserve(14);
|
|
}
|
|
|
|
bool
|
|
fmt::is_specifier(const std::string &name)
|
|
{
|
|
return specifiers().count(name);
|
|
}
|
|
|
|
void
|
|
fmt::handle_specifier(char *&out,
|
|
const size_t &max,
|
|
const uint &idx,
|
|
const spec &spec,
|
|
const arg &val)
|
|
try
|
|
{
|
|
const auto &type(get<1>(val));
|
|
const auto &handler(*specifiers().at(spec.name));
|
|
if(!handler(out, max, spec, val))
|
|
throw invalid_type("`%s' for format specifier '%c%s' for argument #%u",
|
|
type.name(),
|
|
SPECIFIER,
|
|
spec.name.c_str(),
|
|
idx);
|
|
}
|
|
catch(const std::out_of_range &e)
|
|
{
|
|
throw invalid_format("Unhandled specifier `%c%s' for argument #%u in format string",
|
|
SPECIFIER,
|
|
spec.name.c_str(),
|
|
idx);
|
|
}
|
|
catch(const illegal &e)
|
|
{
|
|
throw illegal("Specifier `%c%s' for argument #%u: %s",
|
|
SPECIFIER,
|
|
spec.name.c_str(),
|
|
idx,
|
|
e.what());
|
|
}
|
|
|
|
bool
|
|
fmt::char_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &,
|
|
const arg &val)
|
|
const
|
|
{
|
|
using karma::char_;
|
|
using karma::eps;
|
|
using karma::maxwidth;
|
|
|
|
static const auto throw_illegal([]
|
|
{
|
|
throw illegal("Not a printable character");
|
|
});
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, char()>
|
|
{
|
|
karma::rule<char *, char()> printable
|
|
{
|
|
char_(rfc1459::character::gather(rfc1459::character::PRINT))
|
|
};
|
|
|
|
generator(): grammar{printable} {}
|
|
}
|
|
static const generator;
|
|
|
|
const auto &ptr(get<0>(val));
|
|
const auto &type(get<1>(val));
|
|
if(type == typeid(const char))
|
|
{
|
|
const auto &c(*reinterpret_cast<const char *>(ptr));
|
|
karma::generate(out, maxwidth(max)[generator] | eps[throw_illegal], c);
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
bool
|
|
fmt::int_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &s,
|
|
const arg &val)
|
|
const
|
|
{
|
|
const auto &ptr(get<0>(val));
|
|
const auto &type(get<1>(val));
|
|
|
|
if(type == typeid(const char))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const char *>(ptr));
|
|
|
|
if(type == typeid(const unsigned char))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const unsigned char *>(ptr));
|
|
|
|
if(type == typeid(const short))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const short *>(ptr));
|
|
|
|
if(type == typeid(const unsigned short))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const unsigned short *>(ptr));
|
|
|
|
if(type == typeid(const int))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const int *>(ptr));
|
|
|
|
if(type == typeid(const unsigned int))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const unsigned int *>(ptr));
|
|
|
|
if(type == typeid(const long))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const long *>(ptr));
|
|
|
|
if(type == typeid(const unsigned long))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const unsigned long *>(ptr));
|
|
|
|
if(type == typeid(const long long))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const long long *>(ptr));
|
|
|
|
if(type == typeid(const unsigned long long))
|
|
return generate_integer(out, max, s, *reinterpret_cast<const unsigned long long *>(ptr));
|
|
|
|
if(type == typeid(const char[]))
|
|
{
|
|
size_t test;
|
|
const auto &i(reinterpret_cast<const char *>(ptr));
|
|
const auto len(std::min(max, strlen(i)));
|
|
if(!boost::conversion::try_lexical_convert(i, test))
|
|
throw illegal("The string literal value for integer specifier is not a valid integer");
|
|
|
|
memcpy(out, i, len);
|
|
out += len;
|
|
return true;
|
|
}
|
|
|
|
if(type == typeid(const char *))
|
|
{
|
|
size_t test;
|
|
const auto &i(*reinterpret_cast<const char *const *>(ptr));
|
|
const auto len(std::min(max, strlen(i)));
|
|
if(!boost::conversion::try_lexical_convert(i, test))
|
|
throw illegal("The character buffer for integer specifier is not a valid integer");
|
|
|
|
memcpy(out, i, len);
|
|
out += len;
|
|
return true;
|
|
}
|
|
|
|
if(type == typeid(const std::string))
|
|
{
|
|
size_t test;
|
|
const auto &i(*reinterpret_cast<const std::string *>(ptr));
|
|
const auto len(std::min(max, i.size()));
|
|
if(!boost::conversion::try_lexical_convert(i, test))
|
|
throw illegal("The string argument for integer specifier is not a valid integer");
|
|
|
|
memcpy(out, i.data(), len);
|
|
out += len;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
fmt::string_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &,
|
|
const arg &val)
|
|
const
|
|
{
|
|
using karma::char_;
|
|
using karma::eps;
|
|
using karma::maxwidth;
|
|
|
|
static const auto throw_illegal([]
|
|
{
|
|
throw illegal("Not a printable string");
|
|
});
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, std::string()>
|
|
{
|
|
karma::rule<char *, std::string()> printable
|
|
{
|
|
+char_(rfc1459::character::gather(rfc1459::character::PRINT))
|
|
};
|
|
|
|
generator(): grammar{printable} {}
|
|
}
|
|
static const generator;
|
|
return generate_string(out, maxwidth(max)[generator] | eps[throw_illegal], val);
|
|
}
|
|
|
|
bool
|
|
fmt::host_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &spec,
|
|
const arg &val)
|
|
const
|
|
{
|
|
using karma::eps;
|
|
using karma::maxwidth;
|
|
|
|
static const auto throw_illegal([]
|
|
{
|
|
throw illegal("Argument is not a valid host string");
|
|
});
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, std::string()>
|
|
{
|
|
generator(): grammar{grammar::hostname} {}
|
|
}
|
|
static const generator;
|
|
return generate_string(out, maxwidth(max)[generator] | eps[throw_illegal], val);
|
|
}
|
|
|
|
bool
|
|
fmt::user_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &spec,
|
|
const arg &val)
|
|
const
|
|
{
|
|
using karma::eps;
|
|
using karma::maxwidth;
|
|
|
|
static const auto throw_illegal([]
|
|
{
|
|
throw illegal("Argument is not a valid user string");
|
|
});
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, std::string()>
|
|
{
|
|
generator(): grammar{grammar::user} {}
|
|
}
|
|
static const generator;
|
|
return generate_string(out, maxwidth(max)[generator] | eps[throw_illegal], val);
|
|
}
|
|
|
|
bool
|
|
fmt::nick_specifier::operator()(char *&out,
|
|
const size_t &max,
|
|
const spec &spec,
|
|
const arg &val)
|
|
const
|
|
{
|
|
using karma::eps;
|
|
using karma::maxwidth;
|
|
|
|
static const auto throw_illegal([]
|
|
{
|
|
throw illegal("Argument is not a valid nick string");
|
|
});
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, std::string()>
|
|
{
|
|
generator(): grammar{grammar::nick} {}
|
|
}
|
|
static const generator;
|
|
return generate_string(out, maxwidth(max)[generator] | eps[throw_illegal], val);
|
|
}
|
|
|
|
template<class integer>
|
|
bool
|
|
fmt::generate_integer(char *&out,
|
|
const size_t &max,
|
|
const spec &s,
|
|
const integer &i)
|
|
{
|
|
using karma::int_;
|
|
using karma::maxwidth;
|
|
|
|
struct generator
|
|
:rfc1459::gen::grammar<char *, integer()>
|
|
{
|
|
karma::rule<char *, integer()> rule
|
|
{
|
|
int_
|
|
};
|
|
|
|
generator(): rfc1459::gen::grammar<char *, integer()>{rule} {}
|
|
}
|
|
static const generator;
|
|
return karma::generate(out, maxwidth(max)[generator], i);
|
|
}
|
|
|
|
template<class generator>
|
|
bool
|
|
fmt::generate_string(char *&out,
|
|
const generator &gen,
|
|
const arg &val)
|
|
{
|
|
using karma::eps;
|
|
|
|
const auto &ptr(get<0>(val));
|
|
const auto &type(get<1>(val));
|
|
if(type == typeid(std::string))
|
|
{
|
|
const auto &str(*reinterpret_cast<const std::string *>(ptr));
|
|
karma::generate(out, gen, str);
|
|
return true;
|
|
}
|
|
else if(type == typeid(const char *))
|
|
{
|
|
const auto &str(*reinterpret_cast<const char *const *>(ptr));
|
|
karma::generate(out, gen, str);
|
|
return true;
|
|
}
|
|
|
|
// This for string literals which have unique array types depending on their size.
|
|
// There is no reasonable way to match them. The best that can be hoped for is the
|
|
// grammar will fail gracefully (most of the time) or not print something bogus when
|
|
// it happens to be legal.
|
|
const auto &str(reinterpret_cast<const char *>(ptr));
|
|
return karma::generate(out, gen, str);
|
|
}
|