erf_inputs_detail Namespace Reference

Classes
struct	EntryInfo
struct	ScanState

Functions
std::string	prefixed_name (const std::string &name)
std::vector< std::string >	split_values (const std::string &rhs)
bool	is_override (const EntryInfo &first, const std::vector< int > &includes)
void	scan_inputs (const std::string &inputs_file, ScanState &state)

Function Documentation

is_override()

bool erf_inputs_detail::is_override ( const EntryInfo &  first, const std::vector< int > &  includes  )

inline

Whether a key set again where includes are open overrides the setting first: it does when the first setting came from a file this one included earlier (the base + override idiom; ParmParse keeps the last value). A key set twice in one file, in two files included side by side, or in a file and then again in a file it includes afterwards is a duplicate.

    {
        if (first.includes.size() <= includes.size()) { return false; }
        for (std::size_t n = 0; n < includes.size(); ++n) {
            if (first.includes[n] != includes[n]) { return false; }
        }
        return true;
    }

Referenced by scan_inputs().

Here is the caller graph for this function:

prefixed_name()

std::string erf_inputs_detail::prefixed_name ( const std::string &  name )

inline

The name ParmParse opens for an inputs file: $AMREX_INPUTS_FILE_PREFIX, with a trailing '/' added when missing, in front of the name as written (AMReX_ParmParse.cpp, read_file).

    {
        const char* prefix = std::getenv("AMREX_INPUTS_FILE_PREFIX");
        if (prefix == nullptr || prefix[0] == 0) { return name; }
        std::string p(prefix);
        if (p.back() != '/') { p += '/'; }
        return p + name;
    }

Referenced by scan_inputs().

Here is the caller graph for this function:

scan_inputs()

void erf_inputs_detail::scan_inputs ( const std::string &  inputs_file, ScanState &  state  )

inline

Scan one inputs file, and every file it includes with FILE = <name>, the way ParmParse reads them: names are opened with $AMREX_INPUTS_FILE_PREFIX in front, FILE with more than one value is a parameter, UNSET = <keys> drops the keys, [name] starts a table whose keys are name.<key>, and if AMREX_SPACEDIM / #ifdef AMREX_USE_GPU regions that are off are skipped. Records each key with where it was set, and sets found_duplicates when a key is set twice (see is_override). An inputs file that cannot be opened, or that includes itself directly or through others, sets error and stops the scan.

    {
        const std::string name = prefixed_name(inputs_file);
        std::ifstream ifs(name);
 
        if (!ifs.is_open()) {
            state.error = "Could not open inputs file: " + name;
            return;
        }
        std::error_code ec;
        auto canonical = std::filesystem::weakly_canonical(name, ec);
        if (ec) { canonical = std::filesystem::absolute(name); }
        for (const auto& f : state.open_files) {
            if (f == canonical) {
                state.error = "The inputs file " + name + " includes itself (FILE = ...)";
                return;
            }
        }
        state.open_files.push_back(canonical);
        state.includes.push_back(state.next_include++);
 
        // the preprocessor ParmParse applies before it reads the lines (AMReX_ParmParse.cpp, read_file)
        static const std::regex if_regex(R"(^\s*#\s*if\s+\‍(?\s*AMREX_SPACEDIM\s*(>|<|==|>=|<=|!=)\s*([1-3])\s*\)?\s*$)");
        static const std::regex elif_regex(R"(^\s*#\s*elif\s+\‍(?\s*AMREX_SPACEDIM\s*(>|<|==|>=|<=|!=)\s*([1-3])\s*\)?\s*$)");
        static const std::regex else_regex(R"(^\s*#\s*else\s*$)");
        static const std::regex endif_regex(R"(^\s*#\s*endif\s*$)");
        static const std::regex if_gpu_regex(R"(^\s*#\s*ifdef\s+AMREX_USE_GPU\s*$)");
        static const std::regex if_not_gpu_regex(R"(^\s*#\s*ifndef\s+AMREX_USE_GPU\s*$)");
        static const std::regex table_regex(R"(^\[\s*([A-Za-z][A-Za-z0-9_.\-]*)\s*\]$)");
#ifdef AMREX_USE_GPU
        constexpr bool use_gpu = true;
#else
        constexpr bool use_gpu = false;
#endif
        auto dim_true = [] (const std::smatch& sm) {
            const std::string op = sm[1].str();
            const int dim = std::stoi(sm[2].str());
            return (op == "<"  && AMREX_SPACEDIM <  dim) || (op == ">"  && AMREX_SPACEDIM >  dim) ||
                   (op == "==" && AMREX_SPACEDIM == dim) || (op == "<=" && AMREX_SPACEDIM <= dim) ||
                   (op == ">=" && AMREX_SPACEDIM >= dim) || (op == "!=" && AMREX_SPACEDIM != dim);
        };
        std::vector<bool> region_on;  // is each open #if region read?
        std::vector<bool> region_had; // has a branch of each open #if region been read?
 
        std::string table; // the current [name] table, empty at the root
        std::string line;
        int line_number = 0;
 
        while (std::getline(ifs, line))
        {
            ++line_number;
 
            std::smatch sm;
            if (std::regex_match(line, if_gpu_regex) || std::regex_match(line, if_not_gpu_regex)) {
                const bool r = std::regex_match(line, if_gpu_regex) ? use_gpu : !use_gpu;
                region_on.push_back(r); region_had.push_back(r);
                continue;
            } else if (std::regex_match(line, sm, if_regex)) {
                const bool r = dim_true(sm);
                region_on.push_back(r); region_had.push_back(r);
                continue;
            } else if (!region_on.empty() && std::regex_match(line, sm, elif_regex)) {
                const bool r = !region_had.back() && dim_true(sm);
                region_on.back() = r;
                if (r) { region_had.back() = true; }
                continue;
            } else if (!region_on.empty() && std::regex_match(line, else_regex)) {
                region_on.back() = !region_had.back();
                region_had.back() = true;
                continue;
            } else if (!region_on.empty() && std::regex_match(line, endif_regex)) {
                region_on.pop_back(); region_had.pop_back();
                continue;
            }
            bool skip = false;
            for (bool r : region_on) { if (!r) { skip = true; } }
            if (skip) { continue; }
 
            // Remove comments
            auto hash_pos = line.find('#');
            if (hash_pos != std::string::npos) {
                line = line.substr(0, hash_pos);
            }
 
            line = trim_copy(line);
 
            // Skip blank lines
            if (line.empty()) continue;
 
            // A [name] line starts a table: the keys after it are name.<key>
            if (std::regex_match(line, sm, table_regex)) {
                table = sm[1].str();
                continue;
            }
 
            // Skip lines that are not assignments
            auto eq_pos = line.find('=');
            if (eq_pos == std::string::npos) continue;
 
            const std::string def   = trim_copy(line.substr(0, eq_pos));
            const std::string value = trim_copy(line.substr(eq_pos + 1));
            const auto vals = split_values(value);
 
            // FILE = <name> includes another inputs file, whose keys belong to the same deck.
            // ParmParse reads it into a clean table scope.
            if (def == amrex::ParmParse::FileKeyword && vals.size() == 1) {
                scan_inputs(vals.front(), state);
                // stop, closing this file's include on the way out
                if (!state.error.empty()) { break; }
                continue;
            }
 
            // UNSET = <keys> drops the keys (full names, also inside a table), so they may be set again
            if (def == amrex::ParmParse::UnsetKeyword) {
                for (const auto& k : vals) { state.seen.erase(k); }
                continue;
            }
 
            const std::string key = table.empty() ? def : table + "." + def;
            auto it = state.seen.find(key);
 
            if (it == state.seen.end())
            {
                state.seen.emplace(key, EntryInfo{name, line_number, value, state.includes});
            }
            else if (is_override(it->second, state.includes))
            {
                it->second = EntryInfo{name, line_number, value, state.includes};
            }
            else
            {
                state.found_duplicates = true;
 
                amrex::Print()
                    << "\nDuplicate input detected:\n"
                    << "    Key         : " << key << "\n"
                    << "    First line  : " << it->second.line_number << " of " << it->second.file << "\n"
                    << "    Value       : " << it->second.value << "\n"
                    << "    Second line : " << line_number << " of " << name << "\n"
                    << "    Value       : " << value << "\n";
            }
        }
 
        state.includes.pop_back();
        state.open_files.pop_back();
    }

Referenced by CheckForDuplicateInputs().

Here is the call graph for this function:

Here is the caller graph for this function:

split_values()

std::vector<std::string> erf_inputs_detail::split_values ( const std::string &  rhs )

inline

The values on the right of '=': whitespace separates them, and a double-quoted value is one value without its quotes.

    {
        std::vector<std::string> vals;
        std::size_t i = 0;
        while (i < rhs.size()) {
            if (rhs[i] == ' ' || rhs[i] == '\t' || rhs[i] == '\r') { ++i; continue; }
            if (rhs[i] == '"') {
                auto e = rhs.find('"', i + 1);
                if (e == std::string::npos) { e = rhs.size(); }
                vals.push_back(rhs.substr(i + 1, e - i - 1));
                i = e + 1;
            } else {
                auto e = rhs.find_first_of(" \t\r", i);
                if (e == std::string::npos) { e = rhs.size(); }
                vals.push_back(rhs.substr(i, e - i));
                i = e;
            }
        }
        return vals;
    }

Referenced by scan_inputs().

Here is the caller graph for this function: