parse()

static KernelSource MayaFlux::Portal::Graphics::KernelSource::parse ( std::string_view  stringified )

inlinestatic

Parse parameter names and body from a stringified lambda.

Extracts identifiers from the parameter list by stripping type tokens (everything up to and including the last space or * before the identifier). Extracts body as the text between the first { and the matching closing }.

Parameters

stringified

Raw text produced by MF_KERNEL.

Returns

Populated KernelSource.

< Locate parameter list: between first '(' after '[' and its matching ')'

< points at the closing ')'

< Split on ',' and extract the last token (the identifier) from each param

< strip trailing whitespace

< find last space or * - identifier follows

< find next comma not inside <> or ()

Definition at line 73 of file ShaderSpec.hpp.

    {
        KernelSource ks;
        ks.raw = std::string(stringified);
 
        ///< Locate parameter list: between first '(' after '[' and its matching ')'
        const auto bracket = stringified.find('[');
        const auto paren_open = stringified.find('(', bracket);
        if (paren_open == std::string_view::npos)
            return ks;
 
        std::size_t depth = 1;
        std::size_t paren_close = paren_open + 1;
        while (paren_close < stringified.size() && depth > 0) {
            if (stringified[paren_close] == '(') {
                ++depth;
            } else if (stringified[paren_close] == ')') {
                --depth;
            }
            ++paren_close;
        }
        --paren_close; ///< points at the closing ')'
 
        const auto params_text = stringified.substr(paren_open + 1, paren_close - paren_open - 1);
 
        ///< Split on ',' and extract the last token (the identifier) from each param
        auto extract_name = [](std::string_view param) -> std::string {
            ///< strip trailing whitespace
            auto end = param.find_last_not_of(" \t\n\r");
            if (end == std::string_view::npos)
                return {};
            param = param.substr(0, end + 1);
            ///< find last space or * - identifier follows
            auto sep = param.find_last_of(" *\t");
            if (sep == std::string_view::npos)
                return std::string(param);
            return std::string(param.substr(sep + 1));
        };
 
        std::size_t start = 0;
        while (start < params_text.size()) {
            ///< find next comma not inside <> or ()
            int angle = 0, paren = 0;
            std::size_t pos = start;
            while (pos < params_text.size()) {
                char c = params_text[pos];
                if (c == '<') {
                    ++angle;
                } else if (c == '>') {
                    --angle;
                } else if (c == '(') {
                    ++paren;
                } else if (c == ')') {
                    --paren;
                } else if (c == ',' && angle == 0 && paren == 0) {
                    break;
                }
                ++pos;
            }
            auto name = extract_name(params_text.substr(start, pos - start));
            if (!name.empty())
                ks.param_names.push_back(std::move(name));
            start = (pos < params_text.size()) ? pos + 1 : pos;
        }
 
        ///< Locate body: between first '{' after ')' and its matching '}'
        const auto brace_open = stringified.find('{', paren_close);
        if (brace_open == std::string_view::npos)
            return ks;
 
        depth = 1;
        std::size_t brace_close = brace_open + 1;
        while (brace_close < stringified.size() && depth > 0) {
            if (stringified[brace_close] == '{') {
                ++depth;
            } else if (stringified[brace_close] == '}') {
                --depth;
            }
            ++brace_close;
        }
        --brace_close;
 
        ks.body = std::string(stringified.substr(brace_open + 1, brace_close - brace_open - 1));
        return ks;
    }

References body, param_names, and raw.