Slic3r::client::macro_processor Struct Reference

Inheritance diagram for Slic3r::client::macro_processor:

Collaboration diagram for Slic3r::client::macro_processor:

Public Types
typedef qi::rule< Iterator, expr(const MyContext *), skipper >	RuleExpression

Public Member Functions
	macro_processor ()

Public Attributes
qi::rule< Iterator, std::string(const MyContext *), qi::locals< bool >, skipper >	start
qi::rule< Iterator, std::string(), skipper >	text
qi::rule< Iterator, std::string(const MyContext *), skipper >	text_block
qi::rule< Iterator, std::string(const MyContext *), skipper >	block
qi::rule< Iterator, std::string(const MyContext *), skipper >	statement
qi::rule< Iterator, std::string(const MyContext *), skipper >	macros
qi::rule< Iterator, std::string(const MyContext *), skipper >	if_text_block
qi::rule< Iterator, std::string(const MyContext *), skipper >	if_macros
qi::rule< Iterator, std::string(const MyContext *), skipper >	else_macros
qi::rule< Iterator, std::string(const MyContext *), skipper >	legacy_variable_expansion
qi::rule< Iterator, IteratorRange(), skipper >	identifier
qi::rule< Iterator, expr(const MyContext *), qi::locals< bool >, skipper >	conditional_expression
RuleExpression	logical_or_expression
RuleExpression	logical_and_expression
RuleExpression	relational_expression
RuleExpression	additive_expression
RuleExpression	equality_expression
RuleExpression	multiplicative_expression
RuleExpression	unary_expression
RuleExpression	optional_parameter
qi::rule< Iterator, IteratorRange(), skipper >	regular_expression
qi::rule< Iterator, bool(const MyContext *), skipper >	bool_expr_eval
qi::rule< Iterator, OptWithPos(const MyContext *), qi::locals< OptWithPos, int >, skipper >	variable_reference
qi::rule< Iterator, OptWithPos(const MyContext *), skipper >	variable
qi::rule< Iterator, expr(const MyContext *), skipper >	is_nil_test
qi::rule< Iterator, expr(const MyContext *), qi::locals< expr >, skipper >	one_of
qi::rule< Iterator, expr(const MyContext *, const expr &param), skipper >	one_of_list
qi::rule< Iterator, expr(const MyContext *), qi::locals< expr >, skipper >	interpolate_table
qi::rule< Iterator, InterpolateTableContext(const MyContext *, const expr &param), skipper >	interpolate_table_list
qi::rule< Iterator, std::string(const MyContext *), qi::locals< bool >, skipper >	if_else_output
qi::rule< Iterator, std::string(const MyContext *), qi::locals< OptWithPos >, skipper >	assignment_statement
qi::rule< Iterator, std::string(const MyContext *), qi::locals< bool, MyContext::NewOldVariable >, skipper >	new_variable_statement
qi::rule< Iterator, std::vector< expr >(const MyContext *), skipper >	initializer_list
qi::symbols< char >	keywords

Detailed Description

Member Typedef Documentation

RuleExpression

typedef qi::rule<Iterator, expr(const MyContext*), skipper> Slic3r::client::macro_processor::RuleExpression

Constructor & Destructor Documentation

macro_processor()

Slic3r::client::macro_processor::macro_processor ( )

inline

                          : macro_processor::base_type(start)
        {
            using namespace qi::labels;
            qi::alpha_type              alpha;
            qi::alnum_type              alnum;
            qi::eps_type                eps;
            qi::raw_type                raw;
            qi::lit_type                lit;
            qi::lexeme_type             lexeme;
            qi::no_skip_type            no_skip;
            qi::real_parser<double, strict_real_policies_without_nan_inf> strict_double;
            spirit_encoding::char_type  char_;
            utf8_char_parser            utf8char;
            spirit::bool_type           bool_;
            spirit::int_type            int_;
            spirit::double_type         double_;
            spirit_encoding::string_type string;
      spirit::eoi_type      eoi;
      spirit::repository::qi::iter_pos_type iter_pos;
            auto                        kw = spirit::repository::qi::distinct(qi::copy(alnum | '_'));
 
            qi::_val_type               _val;
            qi::_1_type                 _1;
            qi::_2_type                 _2;
            qi::_3_type                 _3;
            qi::_4_type                 _4;
            qi::_a_type                 _a;
            qi::_b_type                 _b;
            qi::_r1_type                _r1;
            qi::_r2_type                _r2;
 
            // Starting symbol of the grammer.
            // The leading eps is required by the "expectation point" operator ">".
            // Without it, some of the errors would not trigger the error handler.
            // Also the start symbol switches between the "full macro syntax" and a "boolean expression only",
            // depending on the context->just_boolean_expression flag. This way a single static expression parser
            // could serve both purposes.
            start =
                (       (eps(px::bind(&MyContext::evaluate_full_macro, _r1)) > text_block(_r1) [_val=_1])
                    |   conditional_expression(_r1) [ px::bind(&expr::evaluate_boolean_to_string, _1, _val) ]
        ) > eoi;
            start.name("start");
            qi::on_error<qi::fail>(start, px::bind(&MyContext::process_error_message, _r1, _4, _1, _2, _3));
 
            text_block = *(
                        text [_val+=_1]
                        // Allow back tracking after '{' in case of a text_block embedded inside a condition.
                        // In that case the inner-most {else} wins and the {if}/{elsif}/{else} shall be paired.
                        // {elsif}/{else} without an {if} will be allowed to back track from the embedded text_block.
                    |   (lit('{') >> (macros(_r1)[_val += _1] > '}') | '}')
                    |   (lit('[') > legacy_variable_expansion(_r1) [_val+=_1] > ']')
                );
            text_block.name("text_block");
 
            // Free-form text up to a first brace, including spaces and newlines.
            // The free-form text will be inserted into the processed text without a modification.
            text = no_skip[raw[+(utf8char - char_('[') - char_('{'))]];
            text.name("text");
 
            // New style of macro expansion.
            // The macro expansion may contain numeric or string expressions, ifs and cases.
            macros =
                +(block(_r1)[_val += _1] | (statement(_r1) > (+lit(';') | &lit('}')))[_val += _1] | +lit(';'));
            macros.name("macro");
            // if_macros and else_macros only differ by the look-ahead ending condition, which is to not have to repeat the last semicolon
            // at the end of the block.
            if_macros = kw["then"] > *(block(_r1)[_val += _1] | (statement(_r1) > (+lit(';') | &(kw["elsif"] | kw["else"] | kw["endif"])))[_val += _1] | +lit(';'));
            if_macros.name("if_macros");
            else_macros = *(block(_r1)[_val += _1] | (statement(_r1) > (+lit(';') | &kw["endif"]))[_val += _1] | +lit(';'));
            else_macros.name("else_macros");
 
            // Blocks do not require a separating semicolon.
            block = 
                    (kw["if"] > if_else_output(_r1)[_val = _1])
                // (kw["switch"] ...
                ;
            block.name("block");
 
            // Statements require a separating semicolon.
            statement =
                  (assignment_statement(_r1)  [_val = _1])
                | (new_variable_statement(_r1)[_val = _1])
                | (conditional_expression(_r1)[px::bind(&expr::to_string2, _1, _val)])
                ;
 
            // An if expression enclosed in {} (the outmost {} are already parsed by the caller).
            // Also }{ could be replaced with ; to simplify writing of pure code.
            if_else_output =
                eps[_a=true] >
                (bool_expr_eval(_r1)[px::bind(&MyContext::block_enter, _r1, _1)] > (if_text_block(_r1) | if_macros(_r1)))
                    [px::bind(&MyContext::block_exit, _r1, _1, _a, _2, _val)] >
                *((kw["elsif"] > bool_expr_eval(_r1)[px::bind(&MyContext::block_enter, _r1, _1 && _a)] > (if_text_block(_r1) | if_macros(_r1)))
                    [px::bind(&MyContext::block_exit, _r1, _1, _a, _2, _val)]) >
                -(kw["else"] > eps[px::bind(&MyContext::block_enter, _r1, _a)] > (if_text_block(_r1) | else_macros(_r1)))
                    [px::bind(&MyContext::block_exit, _r1, _a, _a, _1, _val)] >
                kw["endif"];
            if_else_output.name("if_else_output");
            if_text_block = (lit('}') > text_block(_r1) > '{');
            if_text_block.name("if_text_block");
 
            // A switch expression enclosed in {} (the outmost {} are already parsed by the caller).
/*
            switch_output =
                eps[_b=true] >
                omit[expr(_r1)[_a=_1]] > '}' > text_block(_r1)[px::bind(&expr::set_if_equal, _a, _b, _1, _val)] > '{' >
                *("elsif" > omit[bool_expr_eval(_r1)[_a=_1]] > '}' > text_block(_r1)[px::bind(&expr::set_if, _a, _b, _1, _val)]) >>
                -("else" > '}' >> text_block(_r1)[px::bind(&expr::set_if, _b, _b, _1, _val)]) >
                "endif";
*/
 
            // Legacy variable expansion of the original Slic3r, in the form of [scalar_variable] or [vector_variable_index].
            legacy_variable_expansion =
                    (identifier >> &lit(']'))
                        [ px::bind(&MyContext::legacy_variable_expansion, _r1, _1, _val) ]
                |   (identifier > lit('[') > identifier > ']') 
                        [ px::bind(&MyContext::legacy_variable_expansion2, _r1, _1, _2, _val) ]
                ;
            legacy_variable_expansion.name("legacy_variable_expansion");
 
            identifier =
                ! kw[keywords] >>
                raw[lexeme[(alpha | '_') >> *(alnum | '_')]];
            identifier.name("identifier");
 
            conditional_expression =
                logical_or_expression(_r1) [_val = _1]
                >> -('?' > eps[px::bind(&expr::evaluate_boolean, _val, _a)] >
                      eps[px::bind(&MyContext::block_enter, _r1, _a)] > conditional_expression(_r1)[px::bind(&MyContext::block_exit_ternary, _r1, _a, _1, _val)]
                      > ':' >
                    eps[px::bind(&MyContext::block_enter, _r1, ! _a)] > conditional_expression(_r1)[px::bind(&MyContext::block_exit_ternary, _r1, ! _a, _1, _val)]);
            conditional_expression.name("conditional_expression");
 
            logical_or_expression = 
                logical_and_expression(_r1)                [_val = _1]
                >> *(   ((kw["or"] | "||") > logical_and_expression(_r1) ) [px::bind(&expr::logical_or, _val, _1)] );
            logical_or_expression.name("logical_or_expression");
 
            logical_and_expression = 
                equality_expression(_r1)                   [_val = _1]
                >> *(   ((kw["and"] | "&&") > equality_expression(_r1) ) [px::bind(&expr::logical_and, _val, _1)] );
            logical_and_expression.name("logical_and_expression");
 
            equality_expression =
                relational_expression(_r1)                   [_val = _1]
                >> *(   ("==" > relational_expression(_r1) ) [px::bind(&expr::equal,     _val, _1)]
                    |   ("!=" > relational_expression(_r1) ) [px::bind(&expr::not_equal, _val, _1)]
                    |   ("<>" > relational_expression(_r1) ) [px::bind(&expr::not_equal, _val, _1)]
                    |   ("=~" > regular_expression         ) [px::bind(&expr::regex_matches, _val, _1)]
                    |   ("!~" > regular_expression         ) [px::bind(&expr::regex_doesnt_match, _val, _1)]
                    );
            equality_expression.name("bool expression");
 
            // Evaluate a boolean expression stored as expr into a boolean value.
            // Throw if the equality_expression does not produce a expr of boolean type.
            bool_expr_eval = conditional_expression(_r1) [ px::bind(&expr::evaluate_boolean, _1, _val) ];
            bool_expr_eval.name("bool_expr_eval");
 
            relational_expression = 
                    additive_expression(_r1)                [_val  = _1]
                >> *(   ("<="     > additive_expression(_r1) ) [px::bind(&expr::leq,     _val, _1)]
                    |   (">="     > additive_expression(_r1) ) [px::bind(&expr::geq,     _val, _1)]
                    |   (lit('<') > additive_expression(_r1) ) [px::bind(&expr::lower,   _val, _1)]
                    |   (lit('>') > additive_expression(_r1) ) [px::bind(&expr::greater, _val, _1)]
                    );
            relational_expression.name("relational_expression");
 
            additive_expression =
                multiplicative_expression(_r1)                       [_val  = _1]
                >> *(   (lit('+') > multiplicative_expression(_r1) ) [_val += _1]
                    |   (lit('-') > multiplicative_expression(_r1) ) [_val -= _1]
                    );
            additive_expression.name("additive_expression");
 
            multiplicative_expression =
                unary_expression(_r1)                       [_val  = _1]
                >> *(   (lit('*') > unary_expression(_r1) ) [_val *= _1]
                    |   (lit('/') > unary_expression(_r1) ) [_val /= _1]
                    |   (lit('%') > unary_expression(_r1) ) [_val %= _1]
                    );
            multiplicative_expression.name("multiplicative_expression");
 
            assignment_statement =
                variable_reference(_r1)[_a = _1] >> '=' > 
                (       // Consumes also '(' conditional_expression ')', that means enclosing an expression into braces makes it a single value vector initializer.
                         initializer_list(_r1)[px::bind(&MyContext::vector_variable_assign_initializer_list, _r1, _a, _1)]
                        // Process it before conditional_expression, as conditional_expression requires a vector reference to be augmented with an index.
                        // Only process such variable references, which return a naked vector variable.
                    |  eps(px::bind(&MyContext::is_vector_variable_reference, _a)) >> 
                            variable_reference(_r1)[px::bind(&MyContext::copy_vector_variable_to_vector_variable, _r1, _a, _1)]
                       // Would NOT consume '(' conditional_expression ')' because such value was consumed with the expression above.
                    |  conditional_expression(_r1)
                            [px::bind(&MyContext::scalar_variable_assign_scalar_expression, _r1, _a, _1)]
                    |  (kw["repeat"] > "(" > additive_expression(_r1) > "," > conditional_expression(_r1) > ")")
                            [px::bind(&MyContext::vector_variable_assign_array, _r1, _a, _1, _2)]
                );
  
            new_variable_statement =
                (kw["local"][_a = false] | kw["global"][_a = true]) > identifier[px::bind(&MyContext::new_old_variable, _r1, _a, _1, _b)] > lit('=') >
                (       // Consumes also '(' conditional_expression ')', that means enclosing an expression into braces makes it a single value vector initializer.
                        initializer_list(_r1)[px::bind(&MyContext::vector_variable_new_from_initializer_list, _r1, _a, _b, _1)]
                        // Process it before conditional_expression, as conditional_expression requires a vector reference to be augmented with an index.
                        // Only process such variable references, which return a naked vector variable.
                    |  eps(px::bind(&MyContext::could_be_vector_variable_reference, _b)) >>
                            variable_reference(_r1)[px::ref(qi::_pass) = px::bind(&MyContext::vector_variable_new_from_copy, _r1, _a, _b, _1)]
                       // Would NOT consume '(' conditional_expression ')' because such value was consumed with the expression above.
                    |  conditional_expression(_r1)
                            [px::bind(&MyContext::scalar_variable_new_from_scalar_expression, _r1, _a, _b, _1)]
                    |  (kw["repeat"] > "(" > additive_expression(_r1) > "," > conditional_expression(_r1) > ")")
                            [px::bind(&MyContext::vector_variable_new_from_array, _r1, _a, _b, _1, _2)]
                );
            initializer_list = lit('(') >
                (   lit(')') |
                    (   conditional_expression(_r1)[px::bind(&MyContext::initializer_list_append, _val, _1)] >
                        *(lit(',') > conditional_expression(_r1)[px::bind(&MyContext::initializer_list_append, _val, _1)]) >
                        lit(')')
                    )
                );
 
            unary_expression = iter_pos[px::bind(&FactorActions::set_start_pos, _1, _val)] >> (
                    variable_reference(_r1) [px::bind(&MyContext::variable_value, _r1, _1, _val)]
                |   (lit('(')  > conditional_expression(_r1) > ')' > iter_pos) [ px::bind(&FactorActions::expr_, _1, _2, _val) ]
                |   (lit('-')  > unary_expression(_r1)           )  [ px::bind(&FactorActions::minus_,  _1,     _val) ]
                |   (lit('+')  > unary_expression(_r1) > iter_pos)  [ px::bind(&FactorActions::expr_,   _1, _2, _val) ]
                |   ((kw["not"] | '!') > unary_expression(_r1) > iter_pos) [ px::bind(&FactorActions::not_, _1, _val) ]
                |   (kw["min"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > ')') 
                                                                    [ px::bind(&expr::min, _val, _2) ]
                |   (kw["max"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > ')') 
                                                                    [ px::bind(&expr::max, _val, _2) ]
                |   (kw["random"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > ')') 
                                                                    [ px::bind(&MyContext::random, _r1, _val, _2) ]
                |   (kw["digits"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > optional_parameter(_r1))
                                                                    [ px::bind(&expr::digits<false>, _val, _2, _3) ]
                |   (kw["zdigits"] > '(' > conditional_expression(_r1) [_val = _1] > ',' > conditional_expression(_r1) > optional_parameter(_r1))
                                                                    [ px::bind(&expr::digits<true>, _val, _2, _3) ]
                |   (kw["int"]   > '(' > conditional_expression(_r1) > ')') [ px::bind(&FactorActions::to_int,  _1, _val) ]
                |   (kw["round"] > '(' > conditional_expression(_r1) > ')') [ px::bind(&FactorActions::round,   _1, _val) ]
                |   (kw["is_nil"] > '(' > variable_reference(_r1) > ')') [px::bind(&MyContext::is_nil_test, _r1, _1, _val)]
                |   (kw["one_of"] > '(' > one_of(_r1) > ')')        [ _val = _1 ]
                |   (kw["empty"] > '(' > variable_reference(_r1) > ')') [px::bind(&MyContext::is_vector_empty, _r1, _1, _val)]
                |   (kw["size"] > '(' > variable_reference(_r1) > ')') [px::bind(&MyContext::vector_size, _r1, _1, _val)]
                |   (kw["interpolate_table"] > '(' > interpolate_table(_r1) > ')') [ _val = _1 ]
                |   (strict_double > iter_pos)                      [ px::bind(&FactorActions::double_, _r1, _1, _2, _val) ]
                |   (int_      > iter_pos)                          [ px::bind(&FactorActions::int_,    _r1, _1, _2, _val) ]
                |   (kw[bool_] > iter_pos)                          [ px::bind(&FactorActions::bool_,   _r1, _1, _2, _val) ]
                |   raw[lexeme['"' > *((utf8char - char_('\\') - char_('"')) | ('\\' > char_)) > '"']]
                                                                    [ px::bind(&FactorActions::string_, _r1, _1,     _val) ]
                );
            unary_expression.name("unary_expression");
 
            one_of = (unary_expression(_r1)[_a = _1] > one_of_list(_r1, _a))[_val = _2];
            one_of.name("one_of");
            one_of_list = 
                eps[px::bind(&expr::one_of_test_init, _val)] >
                (   ( ',' > *(
                        (
                                unary_expression(_r1)[px::bind(&expr::one_of_test<false>, _r2, _1, _val)]
                            |   (lit('~') > unary_expression(_r1))[px::bind(&expr::one_of_test<true>, _r2, _1, _val)]
                            |   regular_expression[px::bind(&expr::one_of_test_regex, _r2, _1, _val)]
                        ) >> -lit(','))
                    )
                  | eps
                );
            one_of_list.name("one_of_list");
 
            interpolate_table = (unary_expression(_r1)[_a = _1] > ',' > interpolate_table_list(_r1, _a))
                [px::bind(&InterpolateTableContext::evaluate, _a, _2, _val)];
            interpolate_table.name("interpolate_table");
            interpolate_table_list =
                eps[px::bind(&InterpolateTableContext::init, _r2)] >
                ( *(( lit('(') > unary_expression(_r1) > ',' > unary_expression(_r1) > ')' ) 
                    [px::bind(&InterpolateTableContext::add_pair, _1, _2, _val)] >> -lit(',')) );
            interpolate_table.name("interpolate_table_list");
 
            optional_parameter = iter_pos[px::bind(&FactorActions::set_start_pos, _1, _val)] >> (
                    lit(')')                                       [ px::bind(&FactorActions::noexpr, _val) ]
                |   (lit(',') > conditional_expression(_r1) > ')') [ _val = _1 ]
                );
            optional_parameter.name("optional_parameter");
 
            variable_reference =
                variable(_r1)[_a=_1] >>
                (
                        ('[' > additive_expression(_r1)[px::bind(&MyContext::evaluate_index, _1, _b)] > ']' > iter_pos)
                            [px::bind(&MyContext::store_variable_index, _r1, _a, _b, _2, _val)]
                    |   eps[_val=_a]
                );
            variable_reference.name("variable reference");
 
            variable = identifier[ px::bind(&MyContext::resolve_variable, _r1, _1, _val) ];
            variable.name("variable name");
 
            regular_expression = raw[lexeme['/' > *((utf8char - char_('\\') - char_('/')) | ('\\' > char_)) > '/']];
            regular_expression.name("regular_expression");
 
            keywords.add
                ("and")
                ("digits")
                ("zdigits")
                ("empty")
                ("if")
                ("int")
                ("is_nil")
                ("local")
                //("inf")
                ("else")
                ("elsif")
                ("endif")
                ("false")
                ("global")
                ("interpolate_table")
                ("min")
                ("max")
                ("random")
                ("repeat")
                ("round")
                ("not")
                ("one_of")
                ("or")
                ("size")
                ("true");
 
            if (0) {
                debug(start);
                debug(text);
                debug(text_block);
                debug(macros);
                debug(if_else_output);
                debug(interpolate_table);
//                debug(switch_output);
                debug(legacy_variable_expansion);
                debug(identifier);
                debug(interpolate_table);
                debug(interpolate_table_list);
                debug(conditional_expression);
                debug(logical_or_expression);
                debug(logical_and_expression);
                debug(equality_expression);
                debug(bool_expr_eval);
                debug(relational_expression);
                debug(additive_expression);
                debug(multiplicative_expression);
                debug(unary_expression);
                debug(one_of);
                debug(one_of_list);
                debug(optional_parameter);
                debug(variable_reference);
                debug(variable);
                debug(regular_expression);
            }
        }

References Slic3r::client::InterpolateTableContext::add_pair(), additive_expression, assignment_statement, block, Slic3r::client::MyContext::block_enter(), Slic3r::client::MyContext::block_exit(), Slic3r::client::MyContext::block_exit_ternary(), Slic3r::client::FactorActions::bool_(), bool_expr_eval, conditional_expression, Slic3r::client::MyContext::copy_vector_variable_to_vector_variable(), Slic3r::client::MyContext::could_be_vector_variable_reference(), Slic3r::client::FactorActions::double_(), else_macros, Slic3r::client::expr::equal(), equality_expression, Slic3r::client::InterpolateTableContext::evaluate(), Slic3r::client::expr::evaluate_boolean(), Slic3r::client::expr::evaluate_boolean_to_string(), Slic3r::client::MyContext::evaluate_full_macro(), Slic3r::client::MyContext::evaluate_index(), Slic3r::client::FactorActions::expr_(), Slic3r::client::expr::geq(), Slic3r::client::expr::greater(), identifier, if_else_output, if_macros, if_text_block, Slic3r::client::InterpolateTableContext::init(), initializer_list, Slic3r::client::MyContext::initializer_list_append(), Slic3r::client::FactorActions::int_(), interpolate_table, interpolate_table_list, Slic3r::client::MyContext::is_nil_test(), Slic3r::client::MyContext::is_vector_empty(), Slic3r::client::MyContext::is_vector_variable_reference(), keywords, Slic3r::client::MyContext::legacy_variable_expansion(), legacy_variable_expansion, Slic3r::client::MyContext::legacy_variable_expansion2(), Slic3r::client::expr::leq(), Slic3r::client::expr::logical_and(), logical_and_expression, Slic3r::client::expr::logical_or(), logical_or_expression, Slic3r::client::expr::lower(), macros, Slic3r::client::expr::max(), Slic3r::client::expr::min(), Slic3r::client::FactorActions::minus_(), multiplicative_expression, Slic3r::client::MyContext::new_old_variable(), new_variable_statement, Slic3r::client::FactorActions::noexpr(), Slic3r::client::FactorActions::not_(), Slic3r::client::expr::not_equal(), one_of, one_of_list, Slic3r::client::expr::one_of_test_init(), Slic3r::client::expr::one_of_test_regex(), optional_parameter, Slic3r::client::MyContext::process_error_message(), Slic3r::client::MyContext::random(), Slic3r::client::expr::regex_doesnt_match(), Slic3r::client::expr::regex_matches(), regular_expression, relational_expression, Slic3r::client::MyContext::resolve_variable(), Slic3r::client::FactorActions::round(), Slic3r::client::MyContext::scalar_variable_assign_scalar_expression(), Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression(), Slic3r::client::FactorActions::set_start_pos(), start, statement, Slic3r::client::MyContext::store_variable_index(), string(), Slic3r::client::FactorActions::string_(), text, text_block, Slic3r::client::FactorActions::to_int(), Slic3r::client::expr::to_string2(), unary_expression, variable, variable_reference, Slic3r::client::MyContext::variable_value(), Slic3r::client::MyContext::vector_size(), Slic3r::client::MyContext::vector_variable_assign_array(), Slic3r::client::MyContext::vector_variable_assign_initializer_list(), Slic3r::client::MyContext::vector_variable_new_from_array(), Slic3r::client::MyContext::vector_variable_new_from_copy(), and Slic3r::client::MyContext::vector_variable_new_from_initializer_list().

Member Data Documentation

additive_expression

RuleExpression Slic3r::client::macro_processor::additive_expression

Referenced by macro_processor().

assignment_statement

qi::rule<Iterator, std::string(const MyContext*), qi::locals<OptWithPos>, skipper> Slic3r::client::macro_processor::assignment_statement

Referenced by macro_processor().

block

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::block

Referenced by macro_processor().

bool_expr_eval

qi::rule<Iterator, bool(const MyContext*), skipper> Slic3r::client::macro_processor::bool_expr_eval

Referenced by macro_processor().

conditional_expression

qi::rule<Iterator, expr(const MyContext*), qi::locals<bool>, skipper> Slic3r::client::macro_processor::conditional_expression

Referenced by macro_processor().

else_macros

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::else_macros

Referenced by macro_processor().

equality_expression

RuleExpression Slic3r::client::macro_processor::equality_expression

Referenced by macro_processor().

identifier

qi::rule<Iterator, IteratorRange(), skipper> Slic3r::client::macro_processor::identifier

Referenced by macro_processor().

if_else_output

qi::rule<Iterator, std::string(const MyContext*), qi::locals<bool>, skipper> Slic3r::client::macro_processor::if_else_output

Referenced by macro_processor().

if_macros

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::if_macros

Referenced by macro_processor().

if_text_block

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::if_text_block

Referenced by macro_processor().

initializer_list

qi::rule<Iterator, std::vector<expr>(const MyContext*), skipper> Slic3r::client::macro_processor::initializer_list

Referenced by macro_processor().

interpolate_table

qi::rule<Iterator, expr(const MyContext*), qi::locals<expr>, skipper> Slic3r::client::macro_processor::interpolate_table

Referenced by macro_processor().

interpolate_table_list

qi::rule<Iterator, InterpolateTableContext(const MyContext*, const expr &param), skipper> Slic3r::client::macro_processor::interpolate_table_list

Referenced by macro_processor().

is_nil_test

qi::rule<Iterator, expr(const MyContext*), skipper> Slic3r::client::macro_processor::is_nil_test

keywords

qi::symbols<char> Slic3r::client::macro_processor::keywords

Referenced by macro_processor().

legacy_variable_expansion

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::legacy_variable_expansion

Referenced by macro_processor().

logical_and_expression

RuleExpression Slic3r::client::macro_processor::logical_and_expression

Referenced by macro_processor().

logical_or_expression

RuleExpression Slic3r::client::macro_processor::logical_or_expression

Referenced by macro_processor().

macros

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::macros

Referenced by macro_processor().

multiplicative_expression

RuleExpression Slic3r::client::macro_processor::multiplicative_expression

Referenced by macro_processor().

new_variable_statement

qi::rule<Iterator, std::string(const MyContext*), qi::locals<bool, MyContext::NewOldVariable>, skipper> Slic3r::client::macro_processor::new_variable_statement

Referenced by macro_processor().

one_of

qi::rule<Iterator, expr(const MyContext*), qi::locals<expr>, skipper> Slic3r::client::macro_processor::one_of

Referenced by macro_processor().

one_of_list

qi::rule<Iterator, expr(const MyContext*, const expr &param), skipper> Slic3r::client::macro_processor::one_of_list

Referenced by macro_processor().

optional_parameter

RuleExpression Slic3r::client::macro_processor::optional_parameter

Referenced by macro_processor().

regular_expression

qi::rule<Iterator, IteratorRange(), skipper> Slic3r::client::macro_processor::regular_expression

Referenced by macro_processor().

relational_expression

RuleExpression Slic3r::client::macro_processor::relational_expression

Referenced by macro_processor().

start

qi::rule<Iterator, std::string(const MyContext*), qi::locals<bool>, skipper> Slic3r::client::macro_processor::start

Referenced by macro_processor().

statement

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::statement

Referenced by macro_processor().

text

qi::rule<Iterator, std::string(), skipper> Slic3r::client::macro_processor::text

Referenced by macro_processor().

text_block

qi::rule<Iterator, std::string(const MyContext*), skipper> Slic3r::client::macro_processor::text_block

Referenced by macro_processor().

unary_expression

RuleExpression Slic3r::client::macro_processor::unary_expression

Referenced by macro_processor().

variable

qi::rule<Iterator, OptWithPos(const MyContext*), skipper> Slic3r::client::macro_processor::variable

Referenced by macro_processor().

variable_reference

qi::rule<Iterator, OptWithPos(const MyContext*), qi::locals<OptWithPos, int>, skipper> Slic3r::client::macro_processor::variable_reference

Referenced by macro_processor().

---

The documentation for this struct was generated from the following file:

• src/libslic3r/PlaceholderParser.cpp