topchetoeu/ppc-lang
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: switched from type const & to const type & syntax

Browse Source
This commit is contained in:
TopchetoEU 2022-09-21 09:37:50 +03:00
parent 7d8c97b235
commit be734b47c3
No known key found for this signature in database
GPG Key ID: 0F2543CA49C81E3A
17 changed files with 64 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/compiler/treeifier.hh
View File

@ -4,8 +4,8 @@
#include "utils/message.hh" #include "utils/message.hh"
namespace ppc::compiler { namespace ppc::compiler {
// bool treeify(ppc::messages::msg_stack_t &msg_stack, std::string const &filename, std::string const &source, namespace_t *pout); // bool treeify(ppc::messages::msg_stack_t &msg_stack, const std::string &filename, const std::string &source, namespace_t *pout);
// bool treeify_file(std::string const &filename, ppc::messages::msg_stack_t &pmsg_stack, namespace_t *pout); // bool treeify_file(const std::string &filename, ppc::messages::msg_stack_t &pmsg_stack, namespace_t *pout);
} }
#endif #endif

4
include/compiler/treeifier/lexer.hh
View File

@ -21,7 +21,7 @@ namespace ppc::comp::tree::lex {
std::string data; std::string data;
ppc::location_t location; ppc::location_t location;
static std::vector<token_t> parse_file(ppc::messages::msg_stack_t &msg_stack, std::string const &filename, std::istream &f); static std::vector<token_t> parse_file(ppc::messages::msg_stack_t &msg_stack, const std::string &filename, std::istream &f);
static std::vector<token_t> parse_many(ppc::messages::msg_stack_t &msg_stack, std::string const &filename, std::string const &src); static std::vector<token_t> parse_many(ppc::messages::msg_stack_t &msg_stack, const std::string &filename, const std::string &src);
}; };
} }

14
include/compiler/treeifier/tokenizer.hh
View File

@ -99,7 +99,7 @@ namespace ppc::comp::tree::tok {
bool is_char_lit() { return kind == CHAR; } bool is_char_lit() { return kind == CHAR; }
bool is_string_lit() { return kind == STRING; } bool is_string_lit() { return kind == STRING; }
auto const &identifier() { const auto &identifier() {
if (!is_identifier()) throw std::string { "Token is not an identifier." }; if (!is_identifier()) throw std::string { "Token is not an identifier." };
else return *data.identifier; else return *data.identifier;
} }
@ -119,7 +119,7 @@ namespace ppc::comp::tree::tok {
if (!is_char_lit()) throw std::string { "Token is not a char literal." }; if (!is_char_lit()) throw std::string { "Token is not a char literal." };
else return data.char_literal; else return data.char_literal;
} }
auto const &string_lit() { const auto &string_lit() {
if (!is_string_lit()) throw std::string { "Token is not a string literal." }; if (!is_string_lit()) throw std::string { "Token is not a string literal." };
else return *data.string_literal; else return *data.string_literal;
} }
@ -128,7 +128,7 @@ namespace ppc::comp::tree::tok {
bool is_identifier(std::string &&val) { return is_identifier() && identifier() == val; } bool is_identifier(std::string &&val) { return is_identifier() && identifier() == val; }
token_t() { kind = NONE; } token_t() { kind = NONE; }
token_t(std::string const &identifier, location_t loc = NO_LOCATION) { token_t(const std::string &identifier, location_t loc = NO_LOCATION) {
kind = IDENTIFIER; kind = IDENTIFIER;
data.identifier = new std::string { identifier }; data.identifier = new std::string { identifier };
location = loc; location = loc;
@ -153,12 +153,12 @@ namespace ppc::comp::tree::tok {
data.char_literal = c; data.char_literal = c;
location = loc; location = loc;
} }
token_t(std::vector<char> const &val, location_t loc = NO_LOCATION) { token_t(const std::vector<char> &val, location_t loc = NO_LOCATION) {
kind = STRING; kind = STRING;
data.string_literal = new std::vector<char> { val }; data.string_literal = new std::vector<char> { val };
location = loc; location = loc;
} }
token_t(token_t const &tok) { token_t(const token_t &tok) {
kind = tok.kind; kind = tok.kind;
switch (kind) { switch (kind) {
case NONE: break; case NONE: break;
@ -184,6 +184,6 @@ namespace ppc::comp::tree::tok {
static std::vector<token_t> parse_many(messages::msg_stack_t &msg_stack, std::vector<lex::token_t> tokens); static std::vector<token_t> parse_many(messages::msg_stack_t &msg_stack, std::vector<lex::token_t> tokens);
}; };
operator_t operator_find(std::string const &text); operator_t operator_find(const std::string &text);
std::string const &operator_stringify(operator_t kw); const std::string &operator_stringify(operator_t kw);
} }

6
include/lang/common.hh
View File

@ -8,11 +8,11 @@ namespace ppc::lang {
std::vector<std::string> segments; std::vector<std::string> segments;
ppc::location_t location; ppc::location_t location;
bool operator ==(namespace_name_t const &other); bool operator ==(const namespace_name_t &other);
}; };
bool is_identifier_valid(messages::msg_stack_t &msg_stack, ppc::location_t location, std::string const &name); bool is_identifier_valid(messages::msg_stack_t &msg_stack, ppc::location_t location, const std::string &name);
inline bool is_identifier_valid(std::string const &name) { inline bool is_identifier_valid(const std::string &name) {
messages::msg_stack_t ms { }; messages::msg_stack_t ms { };
return is_identifier_valid(ms, { }, name); return is_identifier_valid(ms, { }, name);
} }

10
include/lang/namespace.hh
View File

@ -16,21 +16,21 @@ namespace ppc::lang {
// A list of all the defined fields inside the namespace // A list of all the defined fields inside the namespace
std::vector<field_t> fields; std::vector<field_t> fields;
bool contains_def(std::string const &name, location_t &ploc) const; bool contains_def(const std::string &name, location_t &ploc) const;
inline bool contains_def(std::string const &name) const { inline bool contains_def(const std::string &name) const {
location_t ploc; location_t ploc;
return contains_def(name, ploc); return contains_def(name, ploc);
} }
template <class T> template <class T>
static bool contains_def(T namespaces, namespace_name_t const &def_nmsp, std::string const &name, location_t &ploc) { static bool contains_def(T namespaces, const namespace_name_t &def_nmsp, const std::string &name, location_t &ploc) {
for (namespace_t const &nmsp : namespaces) { for (const namespace_t &nmsp : namespaces) {
if (nmsp.name == def_nmsp && nmsp.contains_def(name)) return true; if (nmsp.name == def_nmsp && nmsp.contains_def(name)) return true;
} }
return false; return false;
} }
template <class T> template <class T>
static inline bool contains_def(T namespaces, namespace_name_t const &def_nmsp, std::string const &name) { static inline bool contains_def(T namespaces, const namespace_name_t &def_nmsp, const std::string &name) {
location_t ploc; location_t ploc;
return contains_def(namespaces, def_nmsp, name, ploc); return contains_def(namespaces, def_nmsp, name, ploc);
} }

2
include/utils/message.hh
View File

@ -28,7 +28,7 @@ namespace ppc::messages {
inline auto begin() { return messages.begin(); } inline auto begin() { return messages.begin(); }
inline auto end() { return messages.end(); } inline auto end() { return messages.end(); }
void push(message_t const &msg) { messages.push_back(msg); } void push(const message_t &msg) { messages.push_back(msg); }
void clear() { messages.clear(); } void clear() { messages.clear(); }
bool is_failed() const; bool is_failed() const;

6
include/utils/strings.hh
View File

@ -4,12 +4,12 @@
#include <string> #include <string>
namespace ppc::str { namespace ppc::str {
std::vector<std::string> split(std::string const &splittable, std::initializer_list<char> splitters, bool remove_empty_entries = false); std::vector<std::string> split(const std::string &splittable, std::initializer_list<char> splitters, bool remove_empty_entries = false);
std::string trim(std::string splittable, std::initializer_list<char> splitters = { ' ', '\n', '\t', '\r' }); std::string trim(std::string splittable, std::initializer_list<char> splitters = { ' ', '\n', '\t', '\r' });
inline bool begins_with(std::string const &str, std::string const &other) { inline bool begins_with(const std::string &str, const std::string &other) {
return !str.find(other); return !str.find(other);
} }
inline bool ends_with(std::string const &str, std::string const &other) { inline bool ends_with(const std::string &str, const std::string &other) {
return str.find_last_of(other) == (str.length() - other.length()); return str.find_last_of(other) == (str.length() - other.length());
} }
} }

2
include/utils/threading.hh
View File

@ -21,7 +21,7 @@ namespace ppc::threading {
thread_t(void *handle) { this->handle = handle; } thread_t(void *handle) { this->handle = handle; }
template <class T> template <class T>
inline static thread_t start(thread_func_t<T> func, T const &args) { inline static thread_t start(thread_func_t<T> func, const T &args) {
T _args = args; T _args = args;
return start_impl((void*)func, &_args); return start_impl((void*)func, &_args);
} }

6
src/compiler/treeifier/lexer.cc
View File

@ -330,7 +330,7 @@ const lexlet_t LEXLET_MULTICOMMENT = {
.type = token_t::NONE, .type = token_t::NONE,
}; };
std::vector<token_t> token_t::parse_many(ppc::messages::msg_stack_t &msg_stack, std::string const &filename, std::string const &src) { std::vector<token_t> token_t::parse_many(ppc::messages::msg_stack_t &msg_stack, const std::string &filename, const std::string &src) {
std::vector<token_t> tokens; std::vector<token_t> tokens;
std::vector<char> curr_token; std::vector<char> curr_token;
lexlet_t curr = LEXLET_DEFAULT; lexlet_t curr = LEXLET_DEFAULT;
@ -377,7 +377,7 @@ std::vector<token_t> token_t::parse_many(ppc::messages::msg_stack_t &msg_stack,
i++; i++;
} }
} }
catch (messages::message_t const &msg) { catch (const messages::message_t &msg) {
throw messages::message_t { msg.level, { filename, line, start, i - length, length }, msg.content }; throw messages::message_t { msg.level, { filename, line, start, i - length, length }, msg.content };
} }
} }
@ -392,7 +392,7 @@ std::vector<token_t> token_t::parse_many(ppc::messages::msg_stack_t &msg_stack,
return tokens; return tokens;
} }
std::vector<token_t> token_t::parse_file(ppc::messages::msg_stack_t &msg_stack, std::string const &filename, std::istream &f) { std::vector<token_t> token_t::parse_file(ppc::messages::msg_stack_t &msg_stack, const std::string &filename, std::istream &f) {
std::vector<char> contents; std::vector<char> contents;
int c; int c;

6
src/compiler/treeifier/operators.cc
View File

@ -12,19 +12,19 @@ std::vector<std::string> operators = {
"+", "-", "/", "*", "%", "+", "-", "/", "*", "%",
"?", "??", "?", "??",
"=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "^=", "&=", "|=", "&&=", "||=", "??=", "=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "^=", "&=", "|=", "&&=", "||=", "??=",
"->", ".", ",", ";", ":", "->", ".", ",", ";", ":", "::",
"=>", "=>",
"[", "]", "{", "}", "(", ")" "[", "]", "{", "}", "(", ")"
}; };
std::string const &tok::operator_stringify(tok::operator_t kw) { const std::string &tok::operator_stringify(tok::operator_t kw) {
if (kw < 0 || kw >= operators.size()) throw "Invalid operator ID given."s; if (kw < 0 || kw >= operators.size()) throw "Invalid operator ID given."s;
return operators[kw]; return operators[kw];
} }
tok::operator_t tok::operator_find(const std::string &raw) { tok::operator_t tok::operator_find(const std::string &raw) {
std::size_t i = 0; std::size_t i = 0;
for (auto const &op : operators) { for (const auto &op : operators) {
if (op == raw) return (tok::operator_t)i; if (op == raw) return (tok::operator_t)i;
i++; i++;
} }

6
src/lsproj.cc
View File

@ -8,7 +8,7 @@ struct project_t {
std::vector<std::string> deps; std::vector<std::string> deps;
}; };
std::string read_str(std::istream &f, std::string const &skip_chars, std::string const &end_chars, int &end_char) { std::string read_str(std::istream &f, const std::string &skip_chars, const std::string &end_chars, int &end_char) {
std::vector<char> res { }; std::vector<char> res { };
int c; int c;
@ -41,7 +41,7 @@ std::string read_str(std::istream &f, std::string const &skip_chars, std::string
return std::string { res.begin(), res.end() }; return std::string { res.begin(), res.end() };
} }
std::string read_str(std::istream &f, std::string const &skip_chars, std::string const &end_chars) { std::string read_str(std::istream &f, const std::string &skip_chars, const std::string &end_chars) {
int end_char; int end_char;
return read_str(f, skip_chars, end_chars, end_char); return read_str(f, skip_chars, end_chars, end_char);
} }
@ -87,7 +87,7 @@ project_t read_project(std::istream &f) {
}; };
} }
void print_err(std::string const &error, std::string const &context) { void print_err(const std::string &error, const std::string &context) {
std::cerr << context << ": " << error; std::cerr << context << ": " << error;
} }

26
src/main/main.cc
View File

@ -33,7 +33,7 @@ void add_flags(options::parser_t &parser) {
.name = "version", .name = "version",
.shorthands = "v", .shorthands = "v",
.description = "Displays version and license agreement of this binary", .description = "Displays version and license agreement of this binary",
.execute = [](options::parser_t &parser, std::string const &option, ppc::messages::msg_stack_t &global_stack) { .execute = [](options::parser_t &parser, const std::string &option, ppc::messages::msg_stack_t &global_stack) {
cout << "++C compiler\n" cout << "++C compiler\n"
<< " Version: v" << PPC_VERSION_MAJOR << '.' << PPC_VERSION_MINOR << '.' << PPC_VERSION_BUILD << " Version: v" << PPC_VERSION_MAJOR << '.' << PPC_VERSION_MINOR << '.' << PPC_VERSION_BUILD
#if WINDOWS #if WINDOWS
@ -50,13 +50,13 @@ void add_flags(options::parser_t &parser) {
.name = "help", .name = "help",
.shorthands = "h", .shorthands = "h",
.description = "Displays a list of all flags and their meaning", .description = "Displays a list of all flags and their meaning",
.execute = [](options::parser_t &parser, std::string const &option, ppc::messages::msg_stack_t &global_stack) { .execute = [](options::parser_t &parser, const std::string &option, ppc::messages::msg_stack_t &global_stack) {
cout << "Usage: ...flags ...files\n\n" cout << "Usage: ...flags ...files\n\n"
<< "Flags and file names can be interlaced\n" << "Flags and file names can be interlaced\n"
<< "Flags will execute in the order they're written, then compilation begins\n\n" << "Flags will execute in the order they're written, then compilation begins\n\n"
<< "Flags:\n"; << "Flags:\n";
for (auto const &flag : parser) { for (const auto &flag : parser) {
std::stringstream buff; std::stringstream buff;
buff << " --" << flag.name; buff << " --" << flag.name;
@ -116,7 +116,7 @@ void add_flags(options::parser_t &parser) {
.name = "print-what", .name = "print-what",
.description = "Prints a 'what?' type of message (you'll see)", .description = "Prints a 'what?' type of message (you'll see)",
.match_type = options::MATCH_PREFIX, .match_type = options::MATCH_PREFIX,
.execute = [](options::parser_t &parser, std::string const &option, ppc::messages::msg_stack_t &global_stack) { .execute = [](options::parser_t &parser, const std::string &option, ppc::messages::msg_stack_t &global_stack) {
global_stack.push({ (messages::message_t::level_t)69, NO_LOCATION, "IDK LOL." }); global_stack.push({ (messages::message_t::level_t)69, NO_LOCATION, "IDK LOL." });
} }
}); });
@ -140,28 +140,28 @@ int main(int argc, const char *argv[]) {
data::map_t conf; data::map_t conf;
add_flags(parser); add_flags(parser);
for (auto const &arg : args) { for (const auto &arg : args) {
if (!parser.parse(arg, msg_stack, conf)) { if (!parser.parse(arg, msg_stack, conf)) {
files.push_back(arg); files.push_back(arg);
} }
} }
for (auto const &file : files) { for (const auto &file : files) {
std::ifstream f { file, std::ios_base::in }; std::ifstream f { file, std::ios_base::in };
try { try {
auto res = tok::token_t::parse_many(msg_stack, lex::token_t::parse_file(msg_stack, file, f)); auto res = tok::token_t::parse_many(msg_stack, lex::token_t::parse_file(msg_stack, file, f));
for (auto tok : res) { for (auto tok : res) {
if (tok.is_identifier()) std::cout << "Identifier: " << tok.identifier(); if (tok.is_identifier()) std::cout << "Identifier: \t" << tok.identifier();
if (tok.is_operator()) std::cout << "Operator: " << tok::operator_stringify(tok._operator()); if (tok.is_operator()) std::cout << "Operator: \t" << tok::operator_stringify(tok._operator());
if (tok.is_float_lit()) std::cout << "Float: " << tok.float_lit(); if (tok.is_float_lit()) std::cout << "Float: \t" << tok.float_lit();
if (tok.is_int_lit()) std::cout << "Int: " << tok.int_lit(); if (tok.is_int_lit()) std::cout << "Int: \t" << tok.int_lit();
if (tok.is_char_lit()) std::cout << "Char: " << tok.char_lit(); if (tok.is_char_lit()) std::cout << "Char: \t" << tok.char_lit();
if (tok.is_string_lit()) std::cout << "String: " << std::string { tok.string_lit().begin(), tok.string_lit().end() }; if (tok.is_string_lit()) std::cout << "String: \t" << std::string { tok.string_lit().begin(), tok.string_lit().end() };
std::cout << std::endl; std::cout << std::endl;
} }
} }
catch (messages::message_t const &msg) { catch (const messages::message_t &msg) {
msg_stack.push(msg); msg_stack.push(msg);
} }
} }

6
src/main/opions.hh
View File

@ -17,19 +17,19 @@ namespace ppc::options {
std::string shorthands; std::string shorthands;
std::string description; std::string description;
flag_match_type_t match_type; flag_match_type_t match_type;
void (*execute)(parser_t &parser, std::string const &option, messages::msg_stack_t &global_stack); void (*execute)(parser_t &parser, const std::string &option, messages::msg_stack_t &global_stack);
}; };
struct parser_t { struct parser_t {
private: private:
std::vector<flag_t> flags; std::vector<flag_t> flags;
public: public:
void add_flag(flag_t const &flag); void add_flag(const flag_t &flag);
void clear_flags(); void clear_flags();
auto begin() { return flags.begin(); } auto begin() { return flags.begin(); }
auto end() { return flags.end(); } auto end() { return flags.end(); }
bool parse(std::string const &option, messages::msg_stack_t &msg_stack, data::map_t &conf); bool parse(const std::string &option, messages::msg_stack_t &msg_stack, data::map_t &conf);
}; };
} }

10
src/main/options.cc
View File

@ -3,7 +3,7 @@
using namespace ppc; using namespace ppc;
bool check_shorthand(std::string &option, options::flag_t const &flag) { bool check_shorthand(std::string &option, const options::flag_t &flag) {
if (option.size() < 2 || option[0] != '-') return false; if (option.size() < 2 || option[0] != '-') return false;
if (option.size() == 2 && std::string { flag.shorthands }.find(option[1]) != -1u) { if (option.size() == 2 && std::string { flag.shorthands }.find(option[1]) != -1u) {
@ -17,7 +17,7 @@ bool check_shorthand(std::string &option, options::flag_t const &flag) {
} }
return false; return false;
} }
bool check_name(std::string &option, options::flag_t const &flag) { bool check_name(std::string &option, const options::flag_t &flag) {
if (option.size() > 2 && option[0] == '-' && option[1] == '-') { if (option.size() > 2 && option[0] == '-' && option[1] == '-') {
std::string candidate = option.substr(2); std::string candidate = option.substr(2);
if (flag.match_type == options::MATCH_WHOLE) { if (flag.match_type == options::MATCH_WHOLE) {
@ -41,19 +41,19 @@ bool check_name(std::string &option, options::flag_t const &flag) {
return false; return false;
} }
void ppc::options::parser_t::add_flag(flag_t const &flag) { void ppc::options::parser_t::add_flag(const flag_t &flag) {
flags.push_back(flag); flags.push_back(flag);
} }
void ppc::options::parser_t::clear_flags() { void ppc::options::parser_t::clear_flags() {
flags.clear(); flags.clear();
} }
bool ppc::options::parser_t::parse(std::string const &option, messages::msg_stack_t &msg_stack, data::map_t &conf) { bool ppc::options::parser_t::parse(const std::string &option, messages::msg_stack_t &msg_stack, data::map_t &conf) {
if (option.empty()) return false; if (option.empty()) return false;
std::string opt = option; std::string opt = option;
for (auto const &flag : flags) { for (const auto &flag : flags) {
if (check_name(opt, flag) || check_shorthand(opt, flag)) { if (check_name(opt, flag) || check_shorthand(opt, flag)) {
flag.execute(*this, opt, msg_stack); flag.execute(*this, opt, msg_stack);
return true; return true;

21
src/utils/data.cc
View File

@ -1,9 +1,5 @@
#include "data.hh" #include "data.hh"
template<typename ... Ts>
struct overload : Ts ... { using Ts::operator() ...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;
bool ppc::data::value_t::is_null() const { bool ppc::data::value_t::is_null() const {
return type == type_t::Null; return type == type_t::Null;
} }
@ -59,11 +55,11 @@ bool ppc::data::value_t::boolean(ppc::data::bool_t &out) const {
return false; return false;
} }
ppc::data::array_t const &ppc::data::value_t::array() const { const ppc::data::array_t &ppc::data::value_t::array() const {
if (is_array()) return *val.arr; if (is_array()) return *val.arr;
else throw (std::string)"The value isn't an array."; else throw (std::string)"The value isn't an array.";
} }
ppc::data::map_t const &ppc::data::value_t::map() const { const ppc::data::map_t &ppc::data::value_t::map() const {
if (is_map()) return *val.map; if (is_map()) return *val.map;
else throw (std::string)"The value isn't a map."; else throw (std::string)"The value isn't a map.";
} }
@ -71,7 +67,7 @@ ppc::data::number_t ppc::data::value_t::number() const {
if (is_number()) return val.num; if (is_number()) return val.num;
else throw (std::string)"The value isn't a number."; else throw (std::string)"The value isn't a number.";
} }
ppc::data::string_t const &ppc::data::value_t::string() const { const ppc::data::string_t &ppc::data::value_t::string() const {
if (is_string()) return *val.str; if (is_string()) return *val.str;
else throw (std::string)"The value isn't a string."; else throw (std::string)"The value isn't a string.";
} }
@ -83,15 +79,15 @@ ppc::data::bool_t ppc::data::value_t::boolean() const {
ppc::data::value_t::value_t() { ppc::data::value_t::value_t() {
this->type = type_t::Null; this->type = type_t::Null;
} }
ppc::data::value_t::value_t(ppc::data::array_t const &val) { ppc::data::value_t::value_t(const ppc::data::array_t &val) {
this->type = type_t::Arr; this->type = type_t::Arr;
this->val.arr = new array_t { val }; this->val.arr = new array_t { val };
} }
ppc::data::value_t::value_t(ppc::data::map_t const &val) { ppc::data::value_t::value_t(const ppc::data::map_t &val) {
this->type = type_t::Map; this->type = type_t::Map;
this->val.map = new map_t { val }; this->val.map = new map_t { val };
} }
ppc::data::value_t::value_t(ppc::data::string_t const &val) { ppc::data::value_t::value_t(const ppc::data::string_t &val) {
this->type = type_t::Str; this->type = type_t::Str;
this->val.str = new string_t { val }; this->val.str = new string_t { val };
} }
@ -103,7 +99,7 @@ ppc::data::value_t::value_t(ppc::data::number_t val) {
this->type = type_t::Num; this->type = type_t::Num;
this->val.num = val; this->val.num = val;
} }
ppc::data::value_t::value_t(ppc::data::value_t const &other) { ppc::data::value_t::value_t(const ppc::data::value_t &other) {
type = other.type; type = other.type;
switch (other.type) { switch (other.type) {
case type_t::Map: case type_t::Map:
@ -137,6 +133,3 @@ ppc::data::value_t::~value_t() {
} }
} }
// ppc::data::value_t &ppc::data::value_t::operator=(ppc::data::value_t const &other) {
// return *this;
// }

4
src/utils/message.cc
View File

@ -29,7 +29,7 @@ bool messages::message_t::is_severe() const {
} }
bool messages::msg_stack_t::is_failed() const { bool messages::msg_stack_t::is_failed() const {
for (auto const &msg : messages) { for (const auto &msg : messages) {
if (msg.is_severe()) return true; if (msg.is_severe()) return true;
} }
return false; return false;
@ -37,7 +37,7 @@ bool messages::msg_stack_t::is_failed() const {
void messages::msg_stack_t::print(std::ostream &output, messages::message_t::level_t threshold, bool color_output) const { void messages::msg_stack_t::print(std::ostream &output, messages::message_t::level_t threshold, bool color_output) const {
if (!messages.size()) return; if (!messages.size()) return;
for (auto const &msg : messages) { for (const auto &msg : messages) {
if (msg.level < threshold) continue; if (msg.level < threshold) continue;
std::string loc_readable = msg.location.to_string(); std::string loc_readable = msg.location.to_string();

2
src/utils/strings.cc
View File

@ -3,7 +3,7 @@
using namespace ppc; using namespace ppc;
std::vector<std::string> str::split(std::string const &splittable, std::initializer_list<char> splitters, bool remove_empty_entries) { std::vector<std::string> str::split(const std::string &splittable, std::initializer_list<char> splitters, bool remove_empty_entries) {
std::stringstream buff; std::stringstream buff;
std::vector<std::string> res; std::vector<std::string> res;