diff options
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/option.cpp')
| -rw-r--r-- | debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/option.cpp | 1275 |
1 files changed, 1275 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/option.cpp b/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/option.cpp new file mode 100644 index 00000000..8160c22b --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.75.0/src/option.cpp @@ -0,0 +1,1275 @@ +/** + * @file option.cpp + * Parses the options from the config file. + * + * @author Ben Gardner + * @author Guy Maurel October 2015, 2021 + * @author Matthew Woehlke since version 0.67 + * @license GPL v2+ + */ + +#include "option.h" + +#include "keywords.h" +#include "uncrustify.h" +#include "uncrustify_version.h" + +#include <fstream> +#include <unordered_map> + +#include <cctype> // to get std::tolower +#include <cstdarg> // to get va_start, va_end + + +namespace uncrustify +{ + +namespace +{ + +static const char *DOC_TEXT_END = u8R"___( +# Meaning of the settings: +# Ignore - do not do any changes +# Add - makes sure there is 1 or more space/brace/newline/etc +# Force - makes sure there is exactly 1 space/brace/newline/etc, +# behaves like Add in some contexts +# Remove - removes space/brace/newline/etc +# +# +# - Token(s) can be treated as specific type(s) with the 'set' option: +# `set tokenType tokenString [tokenString...]` +# +# Example: +# `set BOOL __AND__ __OR__` +# +# tokenTypes are defined in src/token_enum.h, use them without the +# 'CT_' prefix: 'CT_BOOL' => 'BOOL' +# +# +# - Token(s) can be treated as type(s) with the 'type' option. +# `type tokenString [tokenString...]` +# +# Example: +# `type int c_uint_8 Rectangle` +# +# This can also be achieved with `set TYPE int c_uint_8 Rectangle` +# +# +# To embed whitespace in tokenStrings use the '\' escape character, or quote +# the tokenStrings. These quotes are supported: "'` +# +# +# - Support for the auto detection of languages through the file ending can be +# added using the 'file_ext' command. +# `file_ext langType langString [langString..]` +# +# Example: +# `file_ext CPP .ch .cxx .cpp.in` +# +# langTypes are defined in uncrusify_types.h in the lang_flag_e enum, use +# them without the 'LANG_' prefix: 'LANG_CPP' => 'CPP' +# +# +# - Custom macro-based indentation can be set up using 'macro-open', +# 'macro-else' and 'macro-close'. +# `(macro-open | macro-else | macro-close) tokenString` +# +# Example: +# `macro-open BEGIN_TEMPLATE_MESSAGE_MAP` +# `macro-open BEGIN_MESSAGE_MAP` +# `macro-close END_MESSAGE_MAP` +# +# +)___"; + + +std::vector<OptionGroup> option_groups; +std::unordered_map<std::string, GenericOption *> option_map; + +#define LOG_CONFIG(...) \ + log_config(); LOG_FMT(LNOTE, __VA_ARGS__); + + +//----------------------------------------------------------------------------- +constexpr int option_level(int major, int minor, int patch = 0) +{ + return((major << 20) | (minor << 10) | (patch << 0)); +} + + +//----------------------------------------------------------------------------- +void log_config() +{ + // Print the name of the configuration file only once + static bool config_name_logged = false; + + if (!config_name_logged) + { + LOG_FMT(LNOTE, "log_config: the configuration file is: %s\n", + cpd.filename.c_str()); + config_name_logged = true; + } +} + + +//----------------------------------------------------------------------------- +// This identity function exists so that all Option<T>::str can simply call +// to_string(m_val); this function will be used by Option<string> +std::string to_string(const std::string &in) +{ + return(in); +} + +using std::to_string; + + +//----------------------------------------------------------------------------- +std::string to_lower(const char *in, std::string::size_type size = 0) +{ + std::string out; + + if (size > 0) + { + out.reserve(size); + } + + while (*in) + { + out += static_cast<char>(std::tolower(*in)); + ++in; + } + return(out); +} + + +//----------------------------------------------------------------------------- +std::string to_lower(const std::string &in) +{ + return(to_lower(in.data(), in.size())); +} + + +//----------------------------------------------------------------------------- +bool is_arg_sep(int ch) +{ + return( isspace(ch) + || ch == ',' + || ch == '='); +} + + +//----------------------------------------------------------------------------- +bool is_varg_sep(int ch) +{ + return(ch == '.'); +} + + +//----------------------------------------------------------------------------- +std::vector<std::string> split_args(std::string in, const char *filename, + bool (*is_sep)(int)) +{ + std::vector<std::string> out; + std::string::size_type n = 0; + std::string::size_type k = in.size(); + + // Parse input string + while (n < k) + { + // Skip leading space + while ( n < k + && is_sep(in[n])) + { + ++n; + } + + // Detect comments or trailing space + if ( n >= k + || in[n] == '#') + { + break; + } + + // Detect and extract quoted string + if (const auto *quote = strchr("\'\"`", in[n])) + { + const auto start = ++n; + + for ((void)n; in[n] != *quote; ++n) + { + if ( n < k + && in[n] == '\\') + { + in.erase(n, 1); + --k; + } + + if (n >= k) + { + OptionWarning w{ filename }; + w("found unterminated quoted-string"); + return{}; + } + } + + out.push_back(in.substr(start, n - start)); + + if ( ++n < k + && !is_sep(in[n])) + { + OptionWarning w{ filename }; + w("unexpected text following quoted-string"); + return{}; + } + continue; + } + // Extract anything else + const auto start = n; + + for ((void)n; + ( n < k + && !is_sep(in[n])); + ++n) + { + if (in[n] == '\\') + { + in.erase(n, 1); + --k; + } + + if (n >= k) + { + OptionWarning w{ filename }; + w("found unterminated quoted-string"); + return{}; + } + } + + out.push_back(in.substr(start, n - start)); + } + return(out); +} // split_args + + +//----------------------------------------------------------------------------- +bool is_path_relative(const std::string &path) +{ + assert(!path.empty()); + +#ifdef WIN32 + // Check for partition labels as indication for an absolute path + // 'X:\path\to\file' style absolute disk path + if ( path.size() > 1 + && isalpha(path[0]) + && path[1] == ':') + { + return(false); + } + + // Check for double backslashs as indication for a network path + // '\\server\path\to\file style' absolute UNC path + if ( path.size() > 1 + && path[0] == '\\' + && path[1] == '\\') + { + return(false); + } +#endif + + // Check for a slash as indication for a filename with leading path + // '/path/to/file' style absolute path + return(path[0] != '/'); +} + + +//----------------------------------------------------------------------------- +void print_description(FILE *pfile, std::string description, + const char *eol_marker) +{ + // Descriptions always start with a '\n', so skip the first character + for (std::string::size_type start = 1, length = description.length(); + ( start != std::string::npos + && start < length); + ++start) + { + // Check for empty line so we can squelch trailing whitespace + if (description[start] == '\n') + { + fprintf(pfile, "#%s", eol_marker); + } + else + { + const auto end = description.find('\n', start); + fprintf(pfile, "# %s%s", + description.substr(start, end - start).c_str(), eol_marker); + start = end; + } + } +} + + +//----------------------------------------------------------------------------- +bool process_option_line_compat_0_68(const std::string &cmd, + const std::vector<std::string> &args, + const char *filename) +{ + if (cmd == "sp_cpp_lambda_paren") + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; use '%s' instead", + cmd.c_str(), options::sp_cpp_lambda_square_paren.name()); + + UNUSED(options::sp_cpp_lambda_square_paren.read(args[1].c_str())); + return(true); + } + return(false); +} // process_option_line_compat_0_68 + + +bool process_option_line_compat_0_70(const std::string &cmd, + const char *filename) +{ + if (cmd == "sp_word_brace") // Issue #2428 + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; did you want to use '%s' instead?", + cmd.c_str(), options::sp_type_brace_init_lst.name()); + + //UNUSED(options::sp_type_brace_init_lst.read(args[1].c_str())); + return(true); + } + return(false); +} // process_option_line_compat_0_70 + + +bool process_option_line_compat_0_73(const std::string &cmd, + const char *filename) +{ + if (cmd == "indent_sing_line_comments") // Issue #3249 + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; did you want to use '%s' instead?", + cmd.c_str(), options::indent_single_line_comments_before.name()); + + //UNUSED(options::indent_single_line_comments_before.read(args[1].c_str())); + return(true); + } + + if (cmd == "sp_before_tr_emb_cmt") // Issue #3339 + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; did you want to use '%s' instead?", + cmd.c_str(), options::sp_before_tr_cmt.name()); + + //UNUSED(options::sp_before_tr_cmt.read(args[1].c_str())); + return(true); + } + + if (cmd == "sp_num_before_tr_emb_cmt") // Issue #3339 + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; did you want to use '%s' instead?", + cmd.c_str(), options::sp_num_before_tr_cmt.name()); + + //UNUSED(options::sp_num_before_tr_cmt.read(args[1].c_str())); + return(true); + } + return(false); +} // process_option_line_compat_0_73 + + +bool process_option_line_compat_0_74(const std::string &cmd, + const char *filename) +{ + if (cmd == "sp_type_question") // PR #3638 + { + OptionWarning w{ filename, OptionWarning::MINOR }; + w("option '%s' is deprecated; did you want to use '%s' instead?", + cmd.c_str(), options::sp_before_ptr_star.name()); + + return(true); + } + return(false); +} // process_option_line_compat_0_74 + +} // namespace + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<T> and helpers + + +//----------------------------------------------------------------------------- +OptionWarning::OptionWarning(const char *filename, Severity severity) +{ + if (severity != MINOR) + { + ++cpd.error_count; + } + + if (cpd.line_number != 0) + { + fprintf(stderr, "%s:%u: ", filename, cpd.line_number); + } + else + { + fprintf(stderr, "%s: ", filename); + } +} + + +//----------------------------------------------------------------------------- +OptionWarning::OptionWarning(const GenericOption *opt, Severity severity) +{ + if (severity != MINOR) + { + ++cpd.error_count; + } + fprintf(stderr, "Option<%s>: at %s:%d: ", to_string(opt->type()), + cpd.filename.c_str(), cpd.line_number); +} + + +//----------------------------------------------------------------------------- +OptionWarning::~OptionWarning() +{ + fprintf(stderr, "\n"); + log_flush(true); +} + + +//----------------------------------------------------------------------------- +void OptionWarning::operator()(const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vfprintf(stderr, fmt, args); + va_end(args); +} + + +//----------------------------------------------------------------------------- +void GenericOption::warnUnexpectedValue(const char *actual) const +{ + OptionWarning w{ this }; + + auto values = possibleValues(); + + if (values[1] == nullptr) + { + w("Expected %s ", *values); + } + else + { + w("Expected one of "); + + while (*values) + { + w("'%s'", *values); + + if (*(++values)) + { + w(", "); + } + } + } + w(", for '%s'; got '%s'", name(), actual); +} + + +//----------------------------------------------------------------------------- +void GenericOption::warnIncompatibleReference(const GenericOption *ref) const +{ + OptionWarning w{ this }; + + w("%s references option %s with incompatible type %s", + name(), ref->name(), to_string(ref->type())); +} + + +//----------------------------------------------------------------------------- +template<typename T> +bool read_enum(const char *in, Option<T> &out) +{ + assert(in); + + if (convert_string(in, out.m_val)) + { + return(true); + } + + if (const auto *const opt = find_option(in)) + { + if (opt->type() != out.type()) + { + out.warnIncompatibleReference(opt); + return(false); + } + auto &topt = *static_cast<const Option<T> *>(opt); + out.m_val = topt(); + return(true); + } + out.warnUnexpectedValue(in); + return(false); +} + + +//----------------------------------------------------------------------------- +template<typename T> +bool read_number(const char *in, Option<T> &out) +{ + assert(in); + + char *c; + const auto val = std::strtol(in, &c, 10); + + if ( *c == 0 + && out.validate(val)) + { + out.m_val = static_cast<T>(val); + return(true); + } + bool invert = false; + + if (strchr("-", in[0])) + { + invert = true; + ++in; + } + + if (const auto *const opt = find_option(in)) + { + LOG_CONFIG("%s(%d): line_number is %d, option(%s) %s, ref(%s) %s\n", + __func__, __LINE__, cpd.line_number, + to_string(out.type()), out.name(), + to_string(opt->type()), opt->name()); + + long tval; + + if (opt->type() == OT_NUM) + { + auto &sopt = *static_cast<const Option<signed> *>(opt); + tval = static_cast<long>(sopt()); + } + else if (opt->type() == OT_UNUM) + { + auto &uopt = *static_cast<const Option<unsigned> *>(opt); + tval = static_cast<long>(uopt()); + } + else + { + out.warnIncompatibleReference(opt); + return(false); + } + const auto rval = (invert ? -tval : tval); + + if (out.validate(rval)) + { + out.m_val = static_cast<T>(rval); + return(true); + } + return(false); + } + out.warnUnexpectedValue(in); + return(false); +} // read_number + + +//----------------------------------------------------------------------------- +template<typename T> +void Option<T>::reset() +{ + m_val = m_default; +} + + +//----------------------------------------------------------------------------- +template<typename T> +std::string Option<T>::str() const +{ + return(to_string(m_val)); +} + + +//----------------------------------------------------------------------------- +template<typename T> +std::string Option<T>::defaultStr() const +{ + return(m_default != T{} ? to_string(m_default) : std::string{}); +} + +// Explicit instantiations +template class Option<bool>; +template class Option<iarf_e>; +template class Option<line_end_e>; +template class Option<token_pos_e>; +template class Option<signed>; +template class Option<unsigned>; +template class Option<std::string>; + +//END Option<T> and helpers + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<bool> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<bool>::type() const +{ + return(OT_BOOL); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<bool>::possibleValues() const +{ + static char const *values[] = { "true", "false", nullptr }; + + return(values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<bool>::read(const char *in) +{ + assert(in); + + if (convert_string(in, m_val)) + { + return(true); + } + bool invert = false; + + if (strchr("~!-", in[0])) + { + invert = true; + ++in; + } + + if (const auto *const opt = find_option(in)) + { + if (opt->type() != OT_BOOL) + { + warnIncompatibleReference(opt); + return(false); + } + auto &bopt = *static_cast<const Option<bool> *>(opt); + m_val = (invert ? !bopt() : bopt()); + return(true); + } + warnUnexpectedValue(in); + return(false); +} + +//END Option<bool> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<iarf_e> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<iarf_e>::type() const +{ + return(OT_IARF); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<iarf_e>::possibleValues() const +{ + return(iarf_values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<iarf_e>::read(const char *in) +{ + return(read_enum(in, *this)); +} + +//END Option<iarf_e> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<line_end_e> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<line_end_e>::type() const +{ + return(OT_LINEEND); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<line_end_e>::possibleValues() const +{ + return(line_end_values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<line_end_e>::read(const char *in) +{ + return(read_enum(in, *this)); +} + +//END Option<line_end_e> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<token_pos_e> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<token_pos_e>::type() const +{ + return(OT_TOKENPOS); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<token_pos_e>::possibleValues() const +{ + return(token_pos_values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<token_pos_e>::read(const char *in) +{ + return(read_enum(in, *this)); +} + +//END Option<token_pos_e> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<signed> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<signed>::type() const +{ + return(OT_NUM); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<signed>::possibleValues() const +{ + static char const *values[] = { "number", nullptr }; + + return(values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<signed>::read(const char *in) +{ + return(read_number(in, *this)); +} + +//END Option<signed> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<unsigned> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<unsigned>::type() const +{ + return(OT_UNUM); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<unsigned>::possibleValues() const +{ + static char const *values[] = { "unsigned number", nullptr }; + + return(values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<unsigned>::read(const char *in) +{ + return(read_number(in, *this)); +} + +//END Option<unsigned> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN Option<string> + + +//----------------------------------------------------------------------------- +template<> +option_type_e Option<std::string>::type() const +{ + return(OT_STRING); +} + + +//----------------------------------------------------------------------------- +template<> +const char *const *Option<std::string>::possibleValues() const +{ + static char const *values[] = { "string", nullptr }; + + return(values); +} + + +//----------------------------------------------------------------------------- +template<> +bool Option<std::string>::read(const char *in) +{ + m_val = in; + return(true); +} + +//END Option<string> + +/////////////////////////////////////////////////////////////////////////////// + +//BEGIN global functions for options + + +//----------------------------------------------------------------------------- +void begin_option_group(const char *description) +{ + auto g = OptionGroup{ description, {} }; + + option_groups.push_back(g); +} + + +//----------------------------------------------------------------------------- +void register_option(GenericOption *option) +{ + assert(!option_groups.empty()); + + option_groups.back().options.push_back(option); + option_map.emplace(option->name(), option); +} + + +//----------------------------------------------------------------------------- +uncrustify::GenericOption *find_option(const char *name) +{ + const auto iter = option_map.find(to_lower(name)); + + if (iter != option_map.end()) + { + return(iter->second); + } + return(nullptr); +} + + +//----------------------------------------------------------------------------- +OptionGroup *get_option_group(size_t i) +{ + if (i >= option_groups.size()) + { + return(nullptr); + } + return(&option_groups[i]); +} + + +//----------------------------------------------------------------------------- +size_t get_option_count() +{ + return(option_map.size()); +} + + +//----------------------------------------------------------------------------- +void process_option_line(const std::string &config_line, const char *filename, + int &compat_level) +{ + // Split line into arguments, and punt if no arguments are present + auto args = split_args(config_line, filename, is_arg_sep); + + if (args.empty()) + { + return; + } + // Check for necessary arguments + const auto &cmd = to_lower(args.front()); + + if ( cmd == "set" + || cmd == "file_ext") + { + if (args.size() < 3) + { + OptionWarning w{ filename }; + w("%s requires at least three arguments", cmd.c_str()); + return; + } + } + else + { + if (args.size() < 2) + { + OptionWarning w{ filename }; + w("%s requires at least two arguments", cmd.c_str()); + return; + } + } + + if (cmd == "type") + { + for (size_t i = 1; i < args.size(); ++i) + { + add_keyword(args[i], CT_TYPE); + } + } + else if (cmd == "macro-open") + { + add_keyword(args[1], CT_MACRO_OPEN); + } + else if (cmd == "macro-close") + { + add_keyword(args[1], CT_MACRO_CLOSE); + } + else if (cmd == "macro-else") + { + add_keyword(args[1], CT_MACRO_ELSE); + } + else if (cmd == "set") + { + const auto token = find_token_name(args[1].c_str()); + + if (token != CT_NONE) + { + LOG_FMT(LNOTE, "%s:%d set '%s':", + filename, cpd.line_number, args[1].c_str()); + + for (size_t i = 2; i < args.size(); ++i) + { + LOG_FMT(LNOTE, " '%s'", args[i].c_str()); + add_keyword(args[i], token); + } + + LOG_FMT(LNOTE, "\n"); + } + else + { + OptionWarning w{ filename }; + w("%s: unknown type '%s'", cmd.c_str(), args[1].c_str()); + } + } +#ifndef EMSCRIPTEN + else if (cmd == "include") + { + auto this_line_number = cpd.line_number; + const auto &include_path = args[1]; + + if (include_path.empty()) + { + OptionWarning w{ filename }; + w("include: path cannot be empty"); + } + else if (is_path_relative(include_path)) + { + // include is a relative path to the current config file + unc_text ut = std::string{ filename }; + ut.resize(static_cast<unsigned>(path_dirname_len(filename))); + ut.append(include_path); + UNUSED(load_option_file(ut.c_str(), compat_level)); + } + else + { + // include is an absolute path + UNUSED(load_option_file(include_path.c_str(), compat_level)); + } + cpd.line_number = this_line_number; + } +#endif + else if (cmd == "file_ext") + { + auto *const lang_arg = args[1].c_str(); + + for (size_t i = 2; i < args.size(); ++i) + { + auto *const lang_name = extension_add(args[i].c_str(), lang_arg); + + if (lang_name) + { + LOG_FMT(LNOTE, "%s:%d file_ext '%s' => '%s'\n", + filename, cpd.line_number, args[i].c_str(), lang_name); + } + else + { + OptionWarning w{ filename }; + w("file_ext: unknown language '%s'", lang_arg); + break; + } + } + } + else if (cmd == "using") + { + auto vargs = split_args(args[1], filename, is_varg_sep); + + if (vargs.size() == 2) + { + compat_level = option_level(std::stoi(vargs[0]), std::stoi(vargs[1])); + } + else if (vargs.size() == 3) + { + compat_level = option_level(std::stoi(vargs[0]), + std::stoi(vargs[1]), + std::stoi(vargs[2])); + } + else + { + OptionWarning w{ filename }; + w("%s requires a version number in the form MAJOR.MINOR[.PATCH]", + cmd.c_str()); + } + } + else + { + // Must be a regular option = value + if (compat_level < option_level(0, 69)) + { + if (process_option_line_compat_0_68(cmd, args, filename)) + { + return; + } + } + + if (compat_level < option_level(0, 71)) + { + if (process_option_line_compat_0_70(cmd, filename)) + { + return; + } + } + + if (compat_level < option_level(0, 74)) + { + if (process_option_line_compat_0_73(cmd, filename)) + { + return; + } + } + + if (compat_level < option_level(0, 75)) + { + if (process_option_line_compat_0_74(cmd, filename)) + { + return; + } + } + const auto oi = option_map.find(cmd); + + if (oi == option_map.end()) + { + OptionWarning w{ filename }; + w("unknown option '%s'", args[0].c_str()); + } + else + { + UNUSED(oi->second->read(args[1].c_str())); + } + } +} // process_option_line + + +//----------------------------------------------------------------------------- +bool load_option_file(const char *filename, int compat_level) +{ + cpd.line_number = 0; + +#ifdef WIN32 + // "/dev/null" not understood by "fopen" in Windows + if (strcasecmp(filename, "/dev/null") == 0) + { + return(true); + } +#endif + + std::ifstream in; + in.open(filename, std::ifstream::in); + + if (!in.good()) + { + OptionWarning w{ filename }; + w("file could not be opened: %s (%d)\n", + strerror(errno), errno); + return(false); + } + // Read in the file line by line + std::string line; + + while (std::getline(in, line)) + { + // check all characters of the line + size_t howmany = line.length(); + int ch; + + for (size_t n = 0; n < howmany; n++) + { + ch = line[n]; + + // do not check characters in comment part of line + if ('#' == ch) + { + break; + } + + // ch >= 0 && ch <= 255 + if ( ch < 0 + || ch > 255) + { + // error + // related to PR #3298 + fprintf(stderr, "%s: line %u: Character at position %zu, is not printable.\n", filename, cpd.line_number + 1, n + 1); + return(false); + } + } + + ++cpd.line_number; + process_option_line(line, filename, compat_level); + } + return(true); +} // load_option_file + + +//----------------------------------------------------------------------------- +const char *get_eol_marker() +{ + static char eol[3] = { 0x0A, 0x00, 0x00 }; + + const auto &lines = cpd.newline.get(); + + for (size_t i = 0; i < lines.size(); ++i) + { + eol[i] = static_cast<char>(lines[i]); + } + + return(eol); +} + + +//----------------------------------------------------------------------------- +void save_option_file(FILE *pfile, bool with_doc, bool minimal) +{ + int non_default_values = 0; + const char *eol_marker = get_eol_marker(); + + fprintf(pfile, "# %s%s", UNCRUSTIFY_VERSION, eol_marker); + + // Print the options by group + for (auto &og : option_groups) + { + bool first = true; + + for (auto *option : og.options) + { + const auto val = option->str(); + + if (!option->isDefault()) + { + ++non_default_values; + } + else if (minimal) + { + continue; + } + //.................................................................... + + if (with_doc) + { + assert(option->description() != nullptr); + assert(*option->description() != 0); + + if (first) + { + fprintf(pfile, "%s#%s", eol_marker, eol_marker); + print_description(pfile, og.description, eol_marker); + fprintf(pfile, "#%s", eol_marker); + } + fprintf(pfile, "%s", eol_marker); + print_description(pfile, option->description(), eol_marker); + + const auto ds = option->defaultStr(); + + if (!ds.empty()) + { + fprintf(pfile, "#%s# Default: %s%s", + eol_marker, ds.c_str(), eol_marker); + } + } + first = false; + + const int name_len = static_cast<int>(strlen(option->name())); + const int pad = name_len < uncrustify::limits::MAX_OPTION_NAME_LEN + ? (uncrustify::limits::MAX_OPTION_NAME_LEN - name_len) + : 1; + + fprintf(pfile, "%s%*.s= ", option->name(), pad, " "); + + if (option->type() == OT_STRING) + { + fprintf(pfile, "\"%s\"", val.c_str()); + } + else + { + fprintf(pfile, "%s", val.c_str()); + } + + if (with_doc) + { + const int val_len = static_cast<int>(val.length()); + fprintf(pfile, "%*.s # ", 8 - val_len, " "); + + for (auto pv = option->possibleValues(); *pv; ++pv) + { + fprintf(pfile, "%s%s", *pv, pv[1] ? "/" : ""); + } + } + fputs(eol_marker, pfile); + } + } + + if (with_doc) + { + fprintf(pfile, "%s", DOC_TEXT_END); + } + print_custom_keywords(pfile); // Print custom keywords + print_extensions(pfile); // Print custom file extensions + + fprintf(pfile, "# option(s) with 'not default' value: %d%s#%s", + non_default_values, eol_marker, eol_marker); +} // save_option_file + +} // namespace uncrustify |