parse()

static FieldSource MayaFlux::Kinesis::FieldSource::parse ( std::string  fn_name, std::string_view  text  )

inlinestatic

Extract return type, parameter list and body from lambda text.

Requires a trailing return type: the return type is read from between the arrow and the opening brace. A lambda without one yields an empty return_type, which valid() reports as a parse failure.

Parameters

fn_name	Name the emitted GLSL function will carry.
text	Raw text produced by MF_FIELD.

Returns

Populated FieldSource.

Definition at line 47 of file FieldSource.hpp.

    {
        FieldSource fs;
        fs.name = std::move(fn_name);
 
        const auto bracket = text.find('[');
        const auto paren_open = text.find('(', bracket);
        if (paren_open == std::string_view::npos)
            return fs;
 
        std::size_t depth = 1;
        std::size_t paren_close = paren_open + 1;
        while (paren_close < text.size() && depth > 0) {
            if (text[paren_close] == '(') {
                ++depth;
            } else if (text[paren_close] == ')') {
                --depth;
            }
            ++paren_close;
        }
        --paren_close;
 
        fs.params = std::string(text.substr(paren_open + 1, paren_close - paren_open - 1));
 
        const auto arrow = text.find("->", paren_close);
        const auto brace_open = text.find('{', paren_close);
        if (brace_open == std::string_view::npos)
            return fs;
 
        if (arrow != std::string_view::npos && arrow < brace_open) {
            auto rt = text.substr(arrow + 2, brace_open - arrow - 2);
            const auto b = rt.find_first_not_of(" \t\n\r");
            const auto e = rt.find_last_not_of(" \t\n\r");
            if (b != std::string_view::npos)
                fs.return_type = std::string(rt.substr(b, e - b + 1));
        }
 
        depth = 1;
        std::size_t brace_close = brace_open + 1;
        while (brace_close < text.size() && depth > 0) {
            if (text[brace_close] == '{') {
                ++depth;
            } else if (text[brace_close] == '}') {
                --depth;
            }
            ++brace_close;
        }
        --brace_close;
 
        fs.body = std::string(text.substr(brace_open + 1, brace_close - brace_open - 1));
        return fs;
    }

References b, body, depth, name, params, and return_type.

Referenced by MayaFlux::Kinesis::dual_field(), and MayaFlux::Kinesis::temporal_field().

Here is the caller graph for this function: