Inheritance diagram for Slic3r::client::MyContext:

Collaboration diagram for Slic3r::client::MyContext:

Classes
struct	NewOldVariable

Public Member Functions
bool	skipping () const

const ConfigOption *	optptr (const t_config_option_key &opt_key) const override

const ConfigOption *	resolve_symbol (const std::string &opt_key) const

ConfigOption *	resolve_output_symbol (const std::string &opt_key) const

void	store_new_variable (const std::string &opt_key, std::unique_ptr< ConfigOption > &&opt, bool global_variable)

bool	has (const t_config_option_key &opt_key) const

const ConfigOption *	option (const t_config_option_key &opt_key) const

template<typename TYPE >
const TYPE *	option (const t_config_option_key &opt_key) const

const ConfigOption *	option_throw (const t_config_option_key &opt_key) const

template<typename TYPE >
const TYPE *	option_throw (const t_config_option_key &opt_key) const

Static Public Member Functions
static bool	evaluate_full_macro (const MyContext *ctx)

static void	block_enter (const MyContext *ctx, const bool condition)

static void	block_exit (const MyContext *ctx, const bool condition, bool &not_yet_consumed, std::string &data_in, std::string &data_out)

static void	block_exit_ternary (const MyContext *ctx, const bool condition, expr &data_in, expr &data_out)

static void	legacy_variable_expansion (const MyContext *ctx, IteratorRange &opt_key, std::string &output)

static void	legacy_variable_expansion2 (const MyContext *ctx, IteratorRange &opt_key, IteratorRange &opt_vector_index, std::string &output)

static void	resolve_variable (const MyContext *ctx, IteratorRange &opt_key, OptWithPos &output)

static void	store_variable_index (const MyContext *ctx, OptWithPos &opt, int index, Iterator it_end, OptWithPos &output)

static void	scalar_variable_to_expr (const MyContext *ctx, OptWithPos &opt, expr &output)

static void	vector_element_to_expr (const MyContext *ctx, OptWithPos &opt, expr &output)

static void	check_writable (const MyContext *ctx, OptWithPos &opt)

static void	check_numeric (const expr &param)

static size_t	evaluate_count (const expr &expr_count)

static void	scalar_variable_assign_scalar (const MyContext *ctx, OptWithPos &lhs, const expr &rhs)

static void	vector_variable_element_assign_scalar (const MyContext *ctx, OptWithPos &lhs, const expr &rhs)

static void	vector_variable_assign_expr_with_count (const MyContext *ctx, OptWithPos &lhs, const expr &rhs_count, const expr &rhs_value)

static void	variable_value (const MyContext *ctx, OptWithPos &opt, expr &output)

static void	is_nil_test (const MyContext *ctx, OptWithPos &opt, expr &output)

static void	new_old_variable (const MyContext *ctx, bool global_variable, const IteratorRange &it_range, NewOldVariable &out)

static void	scalar_variable_assign_scalar_expression (const MyContext *ctx, OptWithPos &opt, const expr &param)

static void	scalar_variable_new_from_scalar_expression (const MyContext *ctx, bool global_variable, NewOldVariable &lhs, const expr &rhs)

static void	vector_variable_new_from_array (const MyContext *ctx, bool global_variable, NewOldVariable &lhs, const expr &rhs_count, const expr &rhs_value)

static void	vector_variable_assign_array (const MyContext *ctx, OptWithPos &lhs, const expr &rhs_count, const expr &rhs_value)

template<typename ConfigOptionType , typename RightValueEvaluate >
static void	fill_vector_from_initializer_list (ConfigOption *opt, const std::vector< expr > &il, RightValueEvaluate rv_eval)

static void	vector_variable_assign_initializer_list (const MyContext *ctx, OptWithPos &lhs, const std::vector< expr > &il)

static void	vector_variable_new_from_initializer_list (const MyContext *ctx, bool global_variable, NewOldVariable &lhs, const std::vector< expr > &il)

static bool	is_vector_variable_reference (const OptWithPos &var)

static bool	could_be_vector_variable_reference (const NewOldVariable &var)

static void	copy_vector_variable_to_vector_variable (const MyContext *ctx, OptWithPos &lhs, const OptWithPos &rhs)

static bool	vector_variable_new_from_copy (const MyContext *ctx, bool global_variable, NewOldVariable &lhs, const OptWithPos &rhs)

static void	initializer_list_append (std::vector< expr > &list, expr &param)

static void	is_vector_empty (const MyContext *ctx, OptWithPos &opt, expr &out)

static void	vector_size (const MyContext *ctx, OptWithPos &opt, expr &out)

static void	evaluate_index (expr &expr_index, int &output)

static void	random (const MyContext *ctx, expr &param1, expr &param2)

static void	throw_exception (const std::string &msg, const IteratorRange &it_range)

static void	process_error_message (const MyContext *context, const boost::spirit::info &info, const Iterator &it_begin, const Iterator &it_end, const Iterator &it_error)

Public Attributes
const DynamicConfig *	external_config = nullptr

const DynamicConfig *	config = nullptr

const DynamicConfig *	config_override = nullptr

DynamicConfig *	config_outputs = nullptr

DynamicConfig	config_local

size_t	current_extruder_id = 0

PlaceholderParser::ContextData *	context_data = nullptr

bool	just_boolean_expression = false

std::string	error_message

Static Public Attributes
static std::map< std::string, std::string >	tag_to_error_message

Private Attributes
int	m_depth_suppressed { 0 }

Detailed Description

Class Documentation

◆ Slic3r::client::MyContext::NewOldVariable

struct Slic3r::client::MyContext::NewOldVariable

Collaboration diagram for Slic3r::client::MyContext::NewOldVariable:

Class Members
IteratorRange	it_range
string	name
ConfigOption *	opt { nullptr }

Member Function Documentation

◆ block_enter()

static void Slic3r::client::MyContext::block_enter	(	const MyContext *	ctx,
		const bool	condition
	)

inlinestatic

        {
            if (ctx->skipping() || ! condition)
                ++ ctx->m_depth_suppressed;
        }

References m_depth_suppressed, and skipping().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_exit()

static void Slic3r::client::MyContext::block_exit	(	const MyContext *	ctx,
		const bool	condition,
		bool &	not_yet_consumed,
		std::string &	data_in,
		std::string &	data_out
	)

inlinestatic

        {
            if (ctx->skipping())
                -- ctx->m_depth_suppressed;
            else if (condition && not_yet_consumed) {
                data_out = std::move(data_in);
                not_yet_consumed = false;
            }
        }

References m_depth_suppressed, and skipping().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ block_exit_ternary()

static void Slic3r::client::MyContext::block_exit_ternary	(	const MyContext *	ctx,
		const bool	condition,
		expr &	data_in,
		expr &	data_out
	)

inlinestatic

        {
            if (ctx->skipping())
                -- ctx->m_depth_suppressed;
            else if (condition)
                data_out = std::move(data_in);
        }

References m_depth_suppressed, and skipping().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_numeric()

static void Slic3r::client::MyContext::check_numeric ( const expr & param )

inlinestatic

                                                     {
            if (! param.numeric_type())
                param.throw_exception("Right side is not a numeric expression");
        };

References Slic3r::client::expr::numeric_type(), and Slic3r::client::expr::throw_exception().

Referenced by scalar_variable_assign_scalar(), vector_variable_assign_expr_with_count(), and vector_variable_element_assign_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_writable()

static void Slic3r::client::MyContext::check_writable	(	const MyContext *	ctx,
		OptWithPos &	opt
	)

inlinestatic

                                                                          {
            if (! opt.writable)
                ctx->throw_exception("Cannot modify a read-only variable", opt.it_range);
        }

References Slic3r::client::OptWithPos::it_range, throw_exception(), and Slic3r::client::OptWithPos::writable.

Referenced by copy_vector_variable_to_vector_variable(), scalar_variable_assign_scalar(), scalar_variable_assign_scalar_expression(), vector_variable_assign_array(), vector_variable_assign_initializer_list(), and vector_variable_element_assign_scalar().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_vector_variable_to_vector_variable()

static void Slic3r::client::MyContext::copy_vector_variable_to_vector_variable	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const OptWithPos &	rhs
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            check_writable(ctx, lhs);
            assert(lhs.opt->is_vector());
            if (rhs.has_index() || ! rhs.opt->is_vector())
                ctx->throw_exception("Cannot assign scalar to a vector", lhs.it_range);
            if (rhs.opt->is_nil())
                ctx->throw_exception("Some elements of the right hand side vector variable of optional values are undefined (nil)", rhs.it_range);
            if (lhs.opt->type() != rhs.opt->type()) {
                // Vector types are not compatible.
                switch (lhs.opt->type()) {
                case coFloats:
                    ctx->throw_exception("Left hand side is a float vector, while the right hand side is not.", lhs.it_range);
                case coInts:
                    ctx->throw_exception("Left hand side is an int vector, while the right hand side is not.", lhs.it_range);
                case coStrings:
                    ctx->throw_exception("Left hand side is a string vector, while the right hand side is not.", lhs.it_range);
                case coBools:
                    ctx->throw_exception("Left hand side is a bool vector, while the right hand side is not.", lhs.it_range);
                default:
                    ctx->throw_exception("Left hand side / right hand side vectors are not compatible.", lhs.it_range);
                }
            }
            const_cast<ConfigOption*>(lhs.opt)->set(rhs.opt);
        }

References check_writable(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coStrings, Slic3r::client::OptWithPos::has_index(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, skipping(), throw_exception(), and Slic3r::ConfigOption::type().

Referenced by Slic3r::client::macro_processor::macro_processor(), and vector_variable_new_from_copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ could_be_vector_variable_reference()

static bool Slic3r::client::MyContext::could_be_vector_variable_reference ( const NewOldVariable & var )

inlinestatic

                                                                                  {
            return var.opt == nullptr || var.opt->is_vector();
        }

References Slic3r::var().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evaluate_count()

static size_t Slic3r::client::MyContext::evaluate_count ( const expr & expr_count )

inlinestatic

                                                             {
            if (expr_count.type() != expr::TYPE_INT)
                expr_count.throw_exception("Expected number of elements to fill a vector with.");
            int count = expr_count.i();
            if (count < 0)
                expr_count.throw_exception("Negative number of elements specified.");
            return size_t(count);
        };

References Slic3r::client::expr::i(), Slic3r::client::expr::throw_exception(), Slic3r::client::expr::type(), and Slic3r::client::expr::TYPE_INT.

Referenced by vector_variable_assign_expr_with_count(), and vector_variable_new_from_array().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evaluate_full_macro()

static bool Slic3r::client::MyContext::evaluate_full_macro ( const MyContext * ctx )

inlinestatic

801{ return ! ctx->just_boolean_expression; }

References just_boolean_expression.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the caller graph for this function:

◆ evaluate_index()

static void Slic3r::client::MyContext::evaluate_index	(	expr &	expr_index,
		int &	output
	)

inlinestatic

        {
            if (expr_index.type() != expr::TYPE_EMPTY) {
                if (expr_index.type() != expr::TYPE_INT)                
                    expr_index.throw_exception("Non-integer index is not allowed to address a vector variable.");
                output = expr_index.i();
            }
        }

References Slic3r::client::expr::i(), Slic3r::client::expr::throw_exception(), Slic3r::client::expr::type(), Slic3r::client::expr::TYPE_EMPTY, and Slic3r::client::expr::TYPE_INT.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fill_vector_from_initializer_list()

template<typename ConfigOptionType , typename RightValueEvaluate >

static void Slic3r::client::MyContext::fill_vector_from_initializer_list	(	ConfigOption *	opt,
		const std::vector< expr > &	il,
		RightValueEvaluate	rv_eval
	)

inlinestatic

                                                                                                                                {
            auto& out = static_cast<ConfigOptionType*>(opt)->values;
            out.clear();
            out.reserve(il.size());
            for (const expr& i : il)
                out.emplace_back(rv_eval(i));
        }

◆ has()

bool Slic3r::ConfigOptionResolver::has ( const t_config_option_key & opt_key ) const

inlineinherited

2105{ return this->optptr(opt_key) != nullptr; }

Slic3r::ConfigOptionResolver::optptr

virtual const ConfigOption * optptr(const t_config_option_key &opt_key) const =0

References Slic3r::ConfigOptionResolver::optptr().

Referenced by Slic3r::GUI::Bed3D::detect_type(), Slic3r::PresetCollection::dirty_options(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::fill_header(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_f(), Slic3r::anonymous_namespace{AnycubicSLA.cpp}::get_cfg_value_i(), Slic3r::GUI::GLGizmoHollow::get_config_options(), Slic3r::GUI::GLGizmoSlaSupports::get_config_options(), Slic3r::GUI::Plater::get_extruder_colors_from_plater_config(), Slic3r::GUI::ConfigOptionsGroup::get_option(), Slic3r::handle_legacy_project_loaded(), Slic3r::handle_legacy_sla(), Slic3r::ModelConfig::has(), Slic3r::PresetCollection::is_dirty(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicConfig::read_cli(), Slic3r::GUI::GLCanvas3D::reload_scene(), Slic3r::Preset::remove_invalid_keys(), and Slic3r::PresetBundle::update_compatible().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initializer_list_append()

static void Slic3r::client::MyContext::initializer_list_append	(	std::vector< expr > &	list,
		expr &	param
	)

inlinestatic

        {
            if (param.type() != expr::TYPE_EMPTY)
                // not skipping
                list.emplace_back(std::move(param));
        }

References Slic3r::client::expr::type(), and Slic3r::client::expr::TYPE_EMPTY.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_nil_test()

static void Slic3r::client::MyContext::is_nil_test	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	output
	)

inlinestatic

        {
            if (ctx->skipping()) {
            } else if (opt.opt->is_vector()) {
                if (! opt.has_index())
                    ctx->throw_exception("Referencing a vector variable when scalar is expected", opt.it_range);
                const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt.opt);
                if (vec->empty())
                    ctx->throw_exception("Indexing an empty vector variable", opt.it_range);
                output.set_b(static_cast<const ConfigOptionVectorBase*>(opt.opt)->is_nil(opt.index >= int(vec->size()) ? 0 : size_t(opt.index)));
            } else {
                assert(opt.opt->is_scalar());
                output.set_b(opt.opt->is_nil());
            }
            output.it_range = opt.it_range;
        }

References Slic3r::ConfigOptionVectorBase::empty(), Slic3r::client::OptWithPos::has_index(), Slic3r::client::OptWithPos::index, Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionVectorBase::is_nil(), Slic3r::ConfigOption::is_scalar(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, Slic3r::client::expr::set_b(), Slic3r::ConfigOptionVectorBase::size(), skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_empty()

static void Slic3r::client::MyContext::is_vector_empty	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	out
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                if (opt.has_index() || ! opt.opt->is_vector())
                    ctx->throw_exception("parameter of empty() is not a vector variable", opt.it_range);
                out.set_b(static_cast<const ConfigOptionVectorBase*>(opt.opt)->size() == 0);
            }
            out.it_range = opt.it_range;
        }

References Slic3r::client::OptWithPos::has_index(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, Slic3r::client::expr::set_b(), Slic3r::ConfigOptionVectorBase::size(), skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_vector_variable_reference()

static bool Slic3r::client::MyContext::is_vector_variable_reference ( const OptWithPos & var )

inlinestatic

                                                                        {
            return ! var.empty() && ! var.has_index() && var.opt->is_vector();
        }

References Slic3r::var().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ legacy_variable_expansion()

static void Slic3r::client::MyContext::legacy_variable_expansion	(	const MyContext *	ctx,
		IteratorRange &	opt_key,
		std::string &	output
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            std::string         opt_key_str(opt_key.begin(), opt_key.end());
            const ConfigOption *opt = ctx->resolve_symbol(opt_key_str);
            size_t              idx = ctx->current_extruder_id;
            if (opt == nullptr) {
                // Check whether this is a legacy vector indexing.
                idx = opt_key_str.rfind('_');
                if (idx != std::string::npos) {
                    opt = ctx->resolve_symbol(opt_key_str.substr(0, idx));
                    if (opt != nullptr) {
                        if (! opt->is_vector())
                            ctx->throw_exception("Trying to index a scalar variable", opt_key);
                        char *endptr = nullptr;
                        idx = strtol(opt_key_str.c_str() + idx + 1, &endptr, 10);
                        if (endptr == nullptr || *endptr != 0)
                            ctx->throw_exception("Invalid vector index", IteratorRange(opt_key.begin() + idx + 1, opt_key.end()));
                    }
                }
            }
            if (opt == nullptr)
                ctx->throw_exception("Variable does not exist", opt_key);
            if (opt->is_scalar()) {
                if (opt->is_nil())
                    ctx->throw_exception("Trying to reference an undefined (nil) optional variable", opt_key);
                output = opt->serialize();
            } else {
                const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt);
                if (vec->empty())
                    ctx->throw_exception("Indexing an empty vector variable", opt_key);
                if (idx >= vec->size())
                    idx = 0;
                if (vec->is_nil(idx))
                    ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt_key);
                output = vec->vserialize()[idx];
            }
        }

References current_extruder_id, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOptionVectorBase::is_nil(), Slic3r::ConfigOption::is_scalar(), Slic3r::ConfigOption::is_vector(), resolve_symbol(), Slic3r::ConfigOption::serialize(), Slic3r::ConfigOptionVectorBase::size(), skipping(), throw_exception(), and Slic3r::ConfigOptionVectorBase::vserialize().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ legacy_variable_expansion2()

static void Slic3r::client::MyContext::legacy_variable_expansion2	(	const MyContext *	ctx,
		IteratorRange &	opt_key,
		IteratorRange &	opt_vector_index,
		std::string &	output
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            std::string         opt_key_str(opt_key.begin(), opt_key.end());
            const ConfigOption *opt = ctx->resolve_symbol(opt_key_str);
            if (opt == nullptr) {
                // Check whether the opt_key ends with '_'.
                if (opt_key_str.back() == '_') {
                    opt_key_str.resize(opt_key_str.size() - 1);
                    opt = ctx->resolve_symbol(opt_key_str);
                }
                if (opt == nullptr)
                    ctx->throw_exception("Variable does not exist", opt_key);
            }
            if (! opt->is_vector())
                ctx->throw_exception("Trying to index a scalar variable", opt_key);
            const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt);
            if (vec->empty())
                ctx->throw_exception("Indexing an empty vector variable", opt_key);
            const ConfigOption *opt_index = ctx->resolve_symbol(std::string(opt_vector_index.begin(), opt_vector_index.end()));
            if (opt_index == nullptr)
                ctx->throw_exception("Variable does not exist", opt_key);
            if (opt_index->type() != coInt)
                ctx->throw_exception("Indexing variable has to be integer", opt_key);
      int idx = opt_index->getInt();
      if (idx < 0)
                ctx->throw_exception("Negative vector index", opt_key);
            if (idx >= (int)vec->size())
                idx = 0;
            if (vec->is_nil(idx))
                ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt_key);
      output = vec->vserialize()[idx];
        }

References Slic3r::coInt, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionVectorBase::is_nil(), Slic3r::ConfigOption::is_vector(), resolve_symbol(), Slic3r::ConfigOptionVectorBase::size(), skipping(), throw_exception(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionVectorBase::vserialize().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ new_old_variable()

static void Slic3r::client::MyContext::new_old_variable	(	const MyContext *	ctx,
		bool	global_variable,
		const IteratorRange &	it_range,
		NewOldVariable &	out
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                t_config_option_key key(std::string(it_range.begin(), it_range.end()));
                if (const ConfigOption* opt = ctx->resolve_symbol(key); opt)
                    ctx->throw_exception("Symbol is already defined in read-only system dictionary", it_range);
                if (ctx->config_outputs && ctx->config_outputs->optptr(key))
                    ctx->throw_exception("Symbol is already defined as system output variable", it_range);
                bool has_global_dictionary = ctx->context_data != nullptr && ctx->context_data->global_config;
                if (global_variable) {
                    if (! has_global_dictionary)
                        ctx->throw_exception("Global variables are not available in this context", it_range);
                    if (ctx->config_local.optptr(key))
                        ctx->throw_exception("Variable name already defined in local scope", it_range);
                    out.opt = ctx->context_data->global_config->optptr(key);
                } else {
                    if (has_global_dictionary && ctx->context_data->global_config->optptr(key))
                        ctx->throw_exception("Variable name already defined in global scope", it_range);
                    out.opt = ctx->config_local.optptr(key);
                }
                out.name     = std::move(key);
            }
            out.it_range = it_range;
        }

References config_local, config_outputs, context_data, Slic3r::PlaceholderParser::ContextData::global_config, Slic3r::client::MyContext::NewOldVariable::it_range, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::client::MyContext::NewOldVariable::opt, Slic3r::DynamicConfig::optptr(), resolve_symbol(), skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ option() [1/2]

const ConfigOption * Slic3r::ConfigOptionResolver::option ( const t_config_option_key & opt_key ) const

inlineinherited

2107{ return this->optptr(opt_key); }

References Slic3r::ConfigOptionResolver::optptr().

Referenced by Slic3r::Flow::extrusion_width(), Slic3r::Flow::extrusion_width(), and Slic3r::PrintObject::invalidate_state_by_config_options().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ option() [2/2]

template<typename TYPE >

const TYPE * Slic3r::ConfigOptionResolver::option ( const t_config_option_key & opt_key ) const

inlineinherited

    {
        const ConfigOption* opt = this->optptr(opt_key);
        return (opt == nullptr || opt->type() != TYPE::static_type()) ? nullptr : static_cast<const TYPE*>(opt);
    }

References Slic3r::ConfigOptionResolver::optptr(), and Slic3r::ConfigOption::type().

Here is the call graph for this function:

◆ option_throw() [1/2]

const ConfigOption * Slic3r::ConfigOptionResolver::option_throw ( const t_config_option_key & opt_key ) const

inlineinherited

    {
        const ConfigOption* opt = this->optptr(opt_key);
        if (opt == nullptr)
            throw UnknownOptionException(opt_key);
        return opt;
    }

References Slic3r::ConfigOptionResolver::optptr().

Referenced by Slic3r::ConfigOptionResolver::option_throw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ option_throw() [2/2]

template<typename TYPE >

const TYPE * Slic3r::ConfigOptionResolver::option_throw ( const t_config_option_key & opt_key ) const

inlineinherited

    {
        const ConfigOption* opt = this->option_throw(opt_key);
        if (opt->type() != TYPE::static_type())
            throw BadOptionTypeException("Conversion to a wrong type");
        return static_cast<TYPE*>(opt);
    }

References Slic3r::ConfigOptionResolver::option_throw(), and Slic3r::ConfigOption::type().

Here is the call graph for this function:

◆ optptr()

const ConfigOption * Slic3r::client::MyContext::optptr ( const t_config_option_key & opt_key ) const

inlineoverridevirtual

Implements Slic3r::ConfigOptionResolver.

        {
            const ConfigOption *opt = nullptr;
            if (config_override != nullptr)
                opt = config_override->option(opt_key);
            if (opt == nullptr)
                opt = config->option(opt_key);
            if (opt == nullptr && external_config != nullptr)
                opt = external_config->option(opt_key);
            return opt;
        }

References config, config_override, external_config, and Slic3r::ConfigBase::option().

Referenced by resolve_symbol().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_error_message()

static void Slic3r::client::MyContext::process_error_message	(	const MyContext *	context,
		const boost::spirit::info &	info,
		const Iterator &	it_begin,
		const Iterator &	it_end,
		const Iterator &	it_error
	)

inlinestatic

        {
            std::string &msg = const_cast<MyContext*>(context)->error_message;
            std::string  first(it_begin, it_error);
            std::string  last(it_error, it_end);
            auto         first_pos  = first.rfind('\n');
            auto         last_pos   = last.find('\n');
            int          line_nr    = 1;
            if (first_pos == std::string::npos)
                first_pos = 0;
            else {
                // Calculate the current line number.
                for (size_t i = 0; i <= first_pos; ++ i)
                    if (first[i] == '\n')
                        ++ line_nr;
                ++ first_pos;
            }
            auto error_line = std::string(first, first_pos) + std::string(last, 0, last_pos);
            // Position of the it_error from the start of its line.
            auto error_pos  = (it_error - it_begin) - first_pos;
            msg += "Parsing error at line " + std::to_string(line_nr);
            if (! info.tag.empty() && info.tag.front() == '*') {
                // The gat contains an explanatory string.
                msg += ": ";
                msg += info.tag.substr(1);
            } else {
                auto it = tag_to_error_message.find(info.tag);
                if (it == tag_to_error_message.end()) {
                    // A generic error report based on the nonterminal or terminal symbol name.
                    msg += ". Expecting tag ";
                    msg += info.tag;
                } else {
                    // Use the human readable error message.
                    msg += ". ";
                    msg += it->second;
                }
            }
            msg += '\n';
            // This hack removes all non-UTF8 characters from the source line, so that the upstream wxWidgets conversions
            // from UTF8 to UTF16 don't bail out.
            msg += boost::nowide::narrow(boost::nowide::widen(error_line));
            msg += '\n';
            for (size_t i = 0; i < error_pos; ++ i)
                msg += ' ';
            msg += "^\n";
        }

References error_message, boost::nowide::narrow(), tag_to_error_message, and boost::nowide::widen().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ random()

static void Slic3r::client::MyContext::random	(	const MyContext *	ctx,
		expr &	param1,
		expr &	param2
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            if (ctx->context_data == nullptr)
                ctx->throw_exception("Random number generator not available in this context.",
                    IteratorRange(param1.it_range.begin(), param2.it_range.end()));
            expr::random(param1, param2, ctx->context_data->rng);
        }

References context_data, Slic3r::client::expr::it_range, Slic3r::client::expr::random(), Slic3r::PlaceholderParser::ContextData::rng, skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_output_symbol()

ConfigOption * Slic3r::client::MyContext::resolve_output_symbol ( const std::string & opt_key ) const

inline

                                                                                      {
            ConfigOption *out = nullptr;
            if (this->config_outputs)
                out = this->config_outputs->optptr(opt_key, false);
            if (out == nullptr && this->context_data != nullptr && this->context_data->global_config)
                out = this->context_data->global_config->optptr(opt_key);
            if (out == nullptr)
                out = this->config_local.optptr(opt_key);
            return out;
        }

References Slic3r::PlaceholderParser::ContextData::global_config, and Slic3r::DynamicConfig::optptr().

Referenced by resolve_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_symbol()

const ConfigOption * Slic3r::client::MyContext::resolve_symbol ( const std::string & opt_key ) const

inline

841{ return this->optptr(opt_key); }

Slic3r::client::MyContext::optptr

const ConfigOption * optptr(const t_config_option_key &opt_key) const override

Definition PlaceholderParser.cpp:829

References optptr().

Referenced by legacy_variable_expansion(), legacy_variable_expansion2(), new_old_variable(), resolve_variable(), and scalar_variable_to_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resolve_variable()

static void Slic3r::client::MyContext::resolve_variable	(	const MyContext *	ctx,
		IteratorRange &	opt_key,
		OptWithPos &	output
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                const std::string key{ opt_key.begin(), opt_key.end() };
                const ConfigOption *opt = ctx->resolve_symbol(key);
                if (opt == nullptr) {
                    opt = ctx->resolve_output_symbol(key);
                    if (opt == nullptr)
                        ctx->throw_exception("Not a variable name", opt_key);
                    output.writable = true;
                }
                output.opt = opt;
            }
            output.it_range = opt_key;
        }

References Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, resolve_output_symbol(), resolve_symbol(), skipping(), throw_exception(), and Slic3r::client::OptWithPos::writable.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scalar_variable_assign_scalar()

static void Slic3r::client::MyContext::scalar_variable_assign_scalar	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const expr &	rhs
	)

inlinestatic

        {
            assert(! ctx->skipping());
            assert(lhs.opt->is_scalar());
            check_writable(ctx, lhs);
            ConfigOption *wropt = const_cast<ConfigOption*>(lhs.opt);
            switch (wropt->type()) {
            case coFloat:
                check_numeric(rhs);
                static_cast<ConfigOptionFloat*>(wropt)->value = rhs.as_d();
                break;
            case coInt:
                check_numeric(rhs);
                static_cast<ConfigOptionInt*>(wropt)->value = rhs.as_i();
                break;
            case coString:
                static_cast<ConfigOptionString*>(wropt)->value = rhs.to_string();
                break;
            case coPercent:
                check_numeric(rhs);
                static_cast<ConfigOptionPercent*>(wropt)->value = rhs.as_d();
                break;
            case coBool:
                if (rhs.type() != expr::TYPE_BOOL)
                    ctx->throw_exception("Right side is not a boolean expression", rhs.it_range);
                static_cast<ConfigOptionBool*>(wropt)->value = rhs.b();
                break;
            default:
                ctx->throw_exception("Unsupported output scalar variable type", lhs.it_range);
            }
        }

References Slic3r::client::expr::as_d(), Slic3r::client::expr::as_i(), Slic3r::client::expr::b(), check_numeric(), check_writable(), Slic3r::coBool, Slic3r::coFloat, Slic3r::coInt, Slic3r::coPercent, Slic3r::coString, Slic3r::ConfigOption::is_scalar(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, skipping(), throw_exception(), Slic3r::client::expr::to_string(), Slic3r::client::expr::type(), Slic3r::ConfigOption::type(), and Slic3r::client::expr::TYPE_BOOL.

Referenced by scalar_variable_assign_scalar_expression(), and scalar_variable_new_from_scalar_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scalar_variable_assign_scalar_expression()

static void Slic3r::client::MyContext::scalar_variable_assign_scalar_expression	(	const MyContext *	ctx,
		OptWithPos &	opt,
		const expr &	param
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                check_writable(ctx, opt);
                if (opt.opt->is_vector())
                    vector_variable_element_assign_scalar(ctx, opt, param);
                else
                    scalar_variable_assign_scalar(ctx, opt, param);
            }
        }

References check_writable(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::opt, scalar_variable_assign_scalar(), skipping(), and vector_variable_element_assign_scalar().

Referenced by Slic3r::client::macro_processor::macro_processor(), and vector_variable_assign_initializer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scalar_variable_new_from_scalar_expression()

static void Slic3r::client::MyContext::scalar_variable_new_from_scalar_expression	(	const MyContext *	ctx,
		bool	global_variable,
		NewOldVariable &	lhs,
		const expr &	rhs
	)

inlinestatic

        {
            if (ctx->skipping()) {
            } else if (lhs.opt) {
                if (lhs.opt->is_vector())
                    rhs.throw_exception("Cannot assign a scalar value to a vector variable.");
                OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                scalar_variable_assign_scalar(ctx, lhs_opt, rhs);
            } else {
                std::unique_ptr<ConfigOption> opt_new;
                switch (rhs.type()) {
                    case expr::TYPE_BOOL:     opt_new = std::make_unique<ConfigOptionBool>(rhs.b());   break;
                    case expr::TYPE_INT:      opt_new = std::make_unique<ConfigOptionInt>(rhs.i());    break;
                    case expr::TYPE_DOUBLE:   opt_new = std::make_unique<ConfigOptionFloat>(rhs.d());  break;
                    case expr::TYPE_STRING:   opt_new = std::make_unique<ConfigOptionString>(rhs.s()); break;
                    default: assert(false);
                }
                const_cast<MyContext*>(ctx)->store_new_variable(lhs.name, std::move(opt_new), global_variable);
            }
        }

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scalar_variable_to_expr()

static void Slic3r::client::MyContext::scalar_variable_to_expr	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	output
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            assert(opt.opt->is_scalar());
 
            if (opt.opt->is_nil())
                ctx->throw_exception("Trying to reference an undefined (nil) optional variable", opt.it_range);
 
            switch (opt.opt->type()) {
            case coFloat:   output.set_d(opt.opt->getFloat());   break;
            case coInt:     output.set_i(opt.opt->getInt());     break;
            case coString:  output.set_s(static_cast<const ConfigOptionString*>(opt.opt)->value); break;
            case coPercent: output.set_d(opt.opt->getFloat());   break;
            case coEnum:
            case coPoint:   output.set_s(opt.opt->serialize());  break;
            case coBool:    output.set_b(opt.opt->getBool());    break;
            case coFloatOrPercent:
            {
                std::string opt_key(opt.it_range.begin(), opt.it_range.end());
                if (boost::ends_with(opt_key, "extrusion_width")) {
                    // Extrusion width supports defaults and a complex graph of dependencies.
                    output.set_d(Flow::extrusion_width(opt_key, *ctx, static_cast<unsigned int>(ctx->current_extruder_id)));
                } else if (! static_cast<const ConfigOptionFloatOrPercent*>(opt.opt)->percent) {
                    // Not a percent, just return the value.
                    output.set_d(opt.opt->getFloat());
                } else {
                    // Resolve dependencies using the "ratio_over" link to a parent value.
              const ConfigOptionDef  *opt_def = print_config_def.get(opt_key);
              assert(opt_def != nullptr);
              double v = opt.opt->getFloat() * 0.01; // percent to ratio
              for (;;) {
                  const ConfigOption *opt_parent = opt_def->ratio_over.empty() ? nullptr : ctx->resolve_symbol(opt_def->ratio_over);
                  if (opt_parent == nullptr)
                      ctx->throw_exception("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies", opt.it_range);
                  if (boost::ends_with(opt_def->ratio_over, "extrusion_width")) {
                        // Extrusion width supports defaults and a complex graph of dependencies.
                            assert(opt_parent->type() == coFloatOrPercent);
                          v *= Flow::extrusion_width(opt_def->ratio_over, static_cast<const ConfigOptionFloatOrPercent*>(opt_parent), *ctx, static_cast<unsigned int>(ctx->current_extruder_id));
                          break;
                        }
                        if (opt_parent->type() == coFloat || opt_parent->type() == coFloatOrPercent) {
                    v *= opt_parent->getFloat();
                    if (opt_parent->type() == coFloat || ! static_cast<const ConfigOptionFloatOrPercent*>(opt_parent)->percent)
                      break;
                    v *= 0.01; // percent to ratio
                  }
                  // Continue one level up in the "ratio_over" hierarchy.
                opt_def = print_config_def.get(opt_def->ratio_over);
                assert(opt_def != nullptr);
              }
                    output.set_d(v);
              }
            break;
        }
            default:
                ctx->throw_exception("Unsupported scalar variable type", opt.it_range);
            }
        }

References Slic3r::coBool, Slic3r::coEnum, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coInt, Slic3r::coPercent, Slic3r::coPoint, Slic3r::coString, current_extruder_id, Slic3r::Flow::extrusion_width(), Slic3r::ConfigDef::get(), Slic3r::ConfigOption::getBool(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOption::is_scalar(), Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, Slic3r::ConfigOptionFloatOrPercent::percent, Slic3r::print_config_def, Slic3r::ConfigOptionDef::ratio_over, resolve_symbol(), Slic3r::ConfigOption::serialize(), Slic3r::client::expr::set_b(), Slic3r::client::expr::set_d(), Slic3r::client::expr::set_i(), Slic3r::client::expr::set_s(), skipping(), throw_exception(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionSingle< T >::value.

Referenced by variable_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ skipping()

bool Slic3r::client::MyContext::skipping ( ) const

inline

827{ return m_depth_suppressed > 0; }

Slic3r::client::MyContext::m_depth_suppressed

int m_depth_suppressed

Definition PlaceholderParser.cpp:1614

References m_depth_suppressed.

Referenced by block_enter(), block_exit(), block_exit_ternary(), Slic3r::client::FactorActions::bool_(), copy_vector_variable_to_vector_variable(), Slic3r::client::FactorActions::double_(), Slic3r::client::FactorActions::int_(), is_nil_test(), is_vector_empty(), legacy_variable_expansion(), legacy_variable_expansion2(), new_old_variable(), random(), resolve_variable(), scalar_variable_assign_scalar(), scalar_variable_assign_scalar_expression(), scalar_variable_new_from_scalar_expression(), scalar_variable_to_expr(), store_variable_index(), Slic3r::client::FactorActions::string_(), variable_value(), vector_element_to_expr(), vector_size(), vector_variable_assign_array(), vector_variable_assign_expr_with_count(), vector_variable_assign_initializer_list(), vector_variable_element_assign_scalar(), vector_variable_new_from_array(), vector_variable_new_from_copy(), and vector_variable_new_from_initializer_list().

Here is the caller graph for this function:

◆ store_new_variable()

void Slic3r::client::MyContext::store_new_variable	(	const std::string &	opt_key,
		std::unique_ptr< ConfigOption > &&	opt,
		bool	global_variable
	)

inline

                                                                                                                                      {
            assert(opt);
            if (global_variable) {
                assert(this->context_data != nullptr && this->context_data->global_config);
                this->context_data->global_config->set_key_value(opt_key, opt.release());
            } else
                this->config_local.set_key_value(opt_key, opt.release());
        }

References Slic3r::PlaceholderParser::ContextData::global_config, and Slic3r::DynamicConfig::set_key_value().

Referenced by scalar_variable_new_from_scalar_expression(), vector_variable_new_from_array(), vector_variable_new_from_copy(), and vector_variable_new_from_initializer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ store_variable_index()

static void Slic3r::client::MyContext::store_variable_index	(	const MyContext *	ctx,
		OptWithPos &	opt,
		int	index,
		Iterator	it_end,
		OptWithPos &	output
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                if (! opt.opt->is_vector())
                    ctx->throw_exception("Cannot index a scalar variable", opt.it_range);
                if (index < 0)
                    ctx->throw_exception("Referencing a vector variable with a negative index", opt.it_range);
                output = opt;
                output.index = index;
            } else
                output = opt;
            output.it_range.end()   = it_end;
        }

References Slic3r::client::OptWithPos::index, Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ throw_exception()

static void Slic3r::client::MyContext::throw_exception	(	const std::string &	msg,
		const IteratorRange &	it_range
	)

inlinestatic

        {
            // An asterix is added to the start of the string to differentiate the boost::spirit::info::tag content
            // between the grammer terminal / non-terminal symbol name and a free-form error message.
            boost::throw_exception(qi::expectation_failure(it_range.begin(), it_range.end(), spirit::info(std::string("*") + msg)));
        }

Referenced by check_writable(), copy_vector_variable_to_vector_variable(), is_nil_test(), is_vector_empty(), legacy_variable_expansion(), legacy_variable_expansion2(), new_old_variable(), Slic3r::client::utf8_char_parser::parse(), Slic3r::client::ascii_char_skipper_parser::parse(), random(), resolve_variable(), scalar_variable_assign_scalar(), scalar_variable_to_expr(), store_variable_index(), Slic3r::client::FactorActions::string_(), vector_element_to_expr(), vector_size(), vector_variable_assign_initializer_list(), vector_variable_element_assign_scalar(), vector_variable_new_from_copy(), and vector_variable_new_from_initializer_list().

Here is the caller graph for this function:

◆ variable_value()

static void Slic3r::client::MyContext::variable_value	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	output
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                if (opt.opt->is_vector())
                    vector_element_to_expr(ctx, opt, output);
                else
                    scalar_variable_to_expr(ctx, opt, output);
            }
            output.it_range = opt.it_range;
        }

References Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, scalar_variable_to_expr(), skipping(), and vector_element_to_expr().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_element_to_expr()

static void Slic3r::client::MyContext::vector_element_to_expr	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	output
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            assert(opt.opt->is_vector());
            if (! opt.has_index())
                ctx->throw_exception("Referencing a vector variable when scalar is expected", opt.it_range);
            const ConfigOptionVectorBase* vec = static_cast<const ConfigOptionVectorBase*>(opt.opt);
            if (vec->empty())
                ctx->throw_exception("Indexing an empty vector variable", opt.it_range);
            size_t idx = (opt.index < 0) ? 0 : (opt.index >= int(vec->size())) ? 0 : size_t(opt.index);
            if (vec->is_nil(idx))
                ctx->throw_exception("Trying to reference an undefined (nil) element of vector of optional values", opt.it_range);
            switch (opt.opt->type()) {
            case coFloats:   output.set_d(static_cast<const ConfigOptionFloats*>(opt.opt)->values[idx]); break;
            case coInts:     output.set_i(static_cast<const ConfigOptionInts*>(opt.opt)->values[idx]); break;
            case coStrings:  output.set_s(static_cast<const ConfigOptionStrings*>(opt.opt)->values[idx]); break;
            case coPercents: output.set_d(static_cast<const ConfigOptionPercents*>(opt.opt)->values[idx]); break;
            case coPoints:   output.set_s(to_string(static_cast<const ConfigOptionPoints*>(opt.opt)->values[idx])); break;
            case coBools:    output.set_b(static_cast<const ConfigOptionBools*>(opt.opt)->values[idx] != 0); break;
                //case coEnums:    output.set_s(opt.opt->vserialize()[idx]); break;
            default:
                ctx->throw_exception("Unsupported vector variable type", opt.it_range);
            }
        }

References Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coStrings, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::client::OptWithPos::has_index(), Slic3r::client::OptWithPos::index, Slic3r::ConfigOptionVectorBase::is_nil(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, Slic3r::client::expr::set_b(), Slic3r::client::expr::set_d(), Slic3r::client::expr::set_i(), Slic3r::client::expr::set_s(), Slic3r::ConfigOptionVectorBase::size(), skipping(), throw_exception(), Slic3r::to_string(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by variable_value().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_size()

static void Slic3r::client::MyContext::vector_size	(	const MyContext *	ctx,
		OptWithPos &	opt,
		expr &	out
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                if (opt.has_index() || ! opt.opt->is_vector())
                    ctx->throw_exception("parameter of size() is not a vector variable", opt.it_range);
                out.set_i(int(static_cast<const ConfigOptionVectorBase*>(opt.opt)->size()));
            }
            out.it_range = opt.it_range;
        }

References Slic3r::client::OptWithPos::has_index(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, Slic3r::client::expr::set_i(), Slic3r::ConfigOptionVectorBase::size(), skipping(), and throw_exception().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_assign_array()

static void Slic3r::client::MyContext::vector_variable_assign_array	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const expr &	rhs_count,
		const expr &	rhs_value
	)

inlinestatic

        {
            if (! ctx->skipping()) {
                check_writable(ctx, lhs);
                if (lhs.opt->is_scalar())
                    rhs_value.throw_exception("Cannot assign a vector value to a scalar variable.");
                vector_variable_assign_expr_with_count(ctx, lhs, rhs_count, rhs_value);
            }
        }

References check_writable(), Slic3r::ConfigOption::is_scalar(), Slic3r::client::OptWithPos::opt, skipping(), Slic3r::client::expr::throw_exception(), and vector_variable_assign_expr_with_count().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_assign_expr_with_count()

static void Slic3r::client::MyContext::vector_variable_assign_expr_with_count	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const expr &	rhs_count,
		const expr &	rhs_value
	)

inlinestatic

        {
            assert(! ctx->skipping());
            size_t count = evaluate_count(rhs_count);
            auto *opt = const_cast<ConfigOption*>(lhs.opt);
            switch (lhs.opt->type()) {
            case coFloats:
                check_numeric(rhs_value);
                static_cast<ConfigOptionFloats*>(opt)->values.assign(count, rhs_value.as_d());
                break;
            case coInts:
                check_numeric(rhs_value);
                static_cast<ConfigOptionInts*>(opt)->values.assign(count, rhs_value.as_i());
                break;
            case coStrings:
                static_cast<ConfigOptionStrings*>(opt)->values.assign(count, rhs_value.to_string());
                break;
            case coBools:
                if (rhs_value.type() != expr::TYPE_BOOL)
                    rhs_value.throw_exception("Right side is not a boolean expression");
                static_cast<ConfigOptionBools*>(opt)->values.assign(count, rhs_value.b());
                break;
            default: assert(false);
            }
        }

References Slic3r::client::expr::as_d(), Slic3r::client::expr::as_i(), Slic3r::client::expr::b(), check_numeric(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coStrings, evaluate_count(), Slic3r::client::OptWithPos::opt, skipping(), Slic3r::client::expr::throw_exception(), Slic3r::client::expr::to_string(), Slic3r::client::expr::type(), Slic3r::ConfigOption::type(), and Slic3r::client::expr::TYPE_BOOL.

Referenced by vector_variable_assign_array(), and vector_variable_new_from_array().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_assign_initializer_list()

static void Slic3r::client::MyContext::vector_variable_assign_initializer_list	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const std::vector< expr > &	il
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            check_writable(ctx, lhs);
 
            if (lhs.opt->is_scalar()) {
                if (il.size() == 1)
                    // scalar_var = ( scalar )
                    scalar_variable_assign_scalar_expression(ctx, lhs, il.front());
                else
                    // scalar_var = () 
                    // or
                    // scalar_var = ( scalar, scalar, ... )
                    ctx->throw_exception("Cannot assign a vector value to a scalar variable.", lhs.it_range);
            }
 
            auto check_numeric_vector = [](const std::vector<expr> &il) {
                for (auto &i : il)
                    if (! i.numeric_type())
                        i.throw_exception("Right side is not a numeric expression");
            };
 
            ConfigOption *opt = const_cast<ConfigOption*>(lhs.opt);
            switch (lhs.opt->type()) {
            case coFloats:
                check_numeric_vector(il);
                fill_vector_from_initializer_list<ConfigOptionFloats>(opt, il, [](auto &v){ return v.as_d(); });
                break;
            case coInts:
                check_numeric_vector(il);
                fill_vector_from_initializer_list<ConfigOptionInts>(opt, il, [](auto &v){ return v.as_i(); });
                break;
            case coStrings:
                fill_vector_from_initializer_list<ConfigOptionStrings>(opt, il, [](auto &v){ return v.to_string(); });
                break;
            case coBools:
                for (auto &i : il)
                    if (i.type() != expr::TYPE_BOOL)
                        i.throw_exception("Right side is not a boolean expression");
                fill_vector_from_initializer_list<ConfigOptionBools>(opt, il, [](auto &v){ return v.b(); });
                break;
            default: assert(false);
            }
        }

References check_writable(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coStrings, Slic3r::ConfigOption::is_scalar(), Slic3r::client::OptWithPos::it_range, Slic3r::client::OptWithPos::opt, scalar_variable_assign_scalar_expression(), skipping(), throw_exception(), Slic3r::ConfigOption::type(), and Slic3r::client::expr::TYPE_BOOL.

Referenced by Slic3r::client::macro_processor::macro_processor(), and vector_variable_new_from_initializer_list().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_element_assign_scalar()

static void Slic3r::client::MyContext::vector_variable_element_assign_scalar	(	const MyContext *	ctx,
		OptWithPos &	lhs,
		const expr &	rhs
	)

inlinestatic

        {
            assert(! ctx->skipping());
            assert(lhs.opt->is_vector());
            check_writable(ctx, lhs);
            if (! lhs.has_index())
                ctx->throw_exception("Referencing an output vector variable when scalar is expected", lhs.it_range);
            ConfigOptionVectorBase *vec = const_cast<ConfigOptionVectorBase*>(static_cast<const ConfigOptionVectorBase*>(lhs.opt));
            if (vec->empty())
                ctx->throw_exception("Indexing an empty vector variable", lhs.it_range);
            if (lhs.index >= int(vec->size()))
                ctx->throw_exception("Index out of range", lhs.it_range);
            switch (lhs.opt->type()) {
            case coFloats:
                check_numeric(rhs);
                static_cast<ConfigOptionFloats*>(vec)->values[lhs.index] = rhs.as_d();
                break;
            case coInts:
                check_numeric(rhs);
                static_cast<ConfigOptionInts*>(vec)->values[lhs.index] = rhs.as_i();
                break;
            case coStrings:
                static_cast<ConfigOptionStrings*>(vec)->values[lhs.index] = rhs.to_string();
                break;
            case coPercents:
                check_numeric(rhs);
                static_cast<ConfigOptionPercents*>(vec)->values[lhs.index] = rhs.as_d();
                break;
            case coBools:
                if (rhs.type() != expr::TYPE_BOOL)
                    ctx->throw_exception("Right side is not a boolean expression", rhs.it_range);
                static_cast<ConfigOptionBools*>(vec)->values[lhs.index] = rhs.b();
                break;
            default:
                ctx->throw_exception("Unsupported output vector variable type", lhs.it_range);
            }
        }

References Slic3r::client::expr::as_d(), Slic3r::client::expr::as_i(), Slic3r::client::expr::b(), check_numeric(), check_writable(), Slic3r::coBools, Slic3r::coFloats, Slic3r::coInts, Slic3r::coPercents, Slic3r::coStrings, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::client::OptWithPos::has_index(), Slic3r::client::OptWithPos::index, Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::expr::it_range, Slic3r::client::OptWithPos::opt, Slic3r::ConfigOptionVectorBase::size(), skipping(), throw_exception(), Slic3r::client::expr::to_string(), Slic3r::client::expr::type(), Slic3r::ConfigOption::type(), and Slic3r::client::expr::TYPE_BOOL.

Referenced by scalar_variable_assign_scalar_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_new_from_array()

static void Slic3r::client::MyContext::vector_variable_new_from_array	(	const MyContext *	ctx,
		bool	global_variable,
		NewOldVariable &	lhs,
		const expr &	rhs_count,
		const expr &	rhs_value
	)

inlinestatic

        {
            if (ctx->skipping()) {
            } else if (lhs.opt) {
                if (lhs.opt->is_scalar())
                    rhs_value.throw_exception("Cannot assign a vector value to a scalar variable.");
                OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                vector_variable_assign_expr_with_count(ctx, lhs_opt, rhs_count, rhs_value);
            } else {
                size_t count = evaluate_count(rhs_count);
                std::unique_ptr<ConfigOption> opt_new;
                switch (rhs_value.type()) {
                    case expr::TYPE_BOOL:     opt_new = std::make_unique<ConfigOptionBools>(count, rhs_value.b());   break;
                    case expr::TYPE_INT:      opt_new = std::make_unique<ConfigOptionInts>(count, rhs_value.i());    break;
                    case expr::TYPE_DOUBLE:   opt_new = std::make_unique<ConfigOptionFloats>(count, rhs_value.d()); break;
                    case expr::TYPE_STRING:   opt_new = std::make_unique<ConfigOptionStrings>(count, rhs_value.s()); break;
                    default: assert(false);
                }
                const_cast<MyContext*>(ctx)->store_new_variable(lhs.name, std::move(opt_new), global_variable);
            }
        }

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_new_from_copy()

static bool Slic3r::client::MyContext::vector_variable_new_from_copy	(	const MyContext *	ctx,
		bool	global_variable,
		NewOldVariable &	lhs,
		const OptWithPos &	rhs
	)

inlinestatic

        {
            if (ctx->skipping())
                // Skipping, continue parsing.
                return true;
 
            if (lhs.opt) {
                assert(lhs.opt->is_vector());
                OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                copy_vector_variable_to_vector_variable(ctx, lhs_opt, rhs);
            } else {
                if (rhs.has_index() || ! rhs.opt->is_vector())
                    // Stop parsing, let the other rules resolve this case.
                    return false;
                if (rhs.opt->is_nil())
                    ctx->throw_exception("Some elements of the right hand side vector variable of optional values are undefined (nil)", rhs.it_range);
                // Clone the vector variable.
                std::unique_ptr<ConfigOption> opt_new;
                if (one_of(rhs.opt->type(), { coFloats, coInts, coStrings, coBools }))
                    opt_new = std::unique_ptr<ConfigOption>(rhs.opt->clone());
                else if (rhs.opt->type() == coPercents)
                    opt_new = std::make_unique<ConfigOptionFloats>(static_cast<const ConfigOptionPercents*>(rhs.opt)->values);
                else
                    ctx->throw_exception("Duplicating this type of vector variable is not supported", rhs.it_range);
                const_cast<MyContext*>(ctx)->store_new_variable(lhs.name, std::move(opt_new), global_variable);
            }
            // Continue parsing.
            return true;
        }

References Slic3r::ConfigOption::clone(), Slic3r::coPercents, copy_vector_variable_to_vector_variable(), Slic3r::client::OptWithPos::has_index(), Slic3r::ConfigOption::is_nil(), Slic3r::ConfigOption::is_vector(), Slic3r::client::OptWithPos::it_range, Slic3r::client::MyContext::NewOldVariable::it_range, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::one_of(), Slic3r::client::OptWithPos::opt, Slic3r::client::MyContext::NewOldVariable::opt, skipping(), store_new_variable(), throw_exception(), Slic3r::ConfigOption::type(), and Slic3r::ConfigOptionVector< T >::values.

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vector_variable_new_from_initializer_list()

static void Slic3r::client::MyContext::vector_variable_new_from_initializer_list	(	const MyContext *	ctx,
		bool	global_variable,
		NewOldVariable &	lhs,
		const std::vector< expr > &	il
	)

inlinestatic

        {
            if (ctx->skipping())
                return;
 
            if (lhs.opt) {
                // Assign to an existing vector variable.
                OptWithPos lhs_opt{ lhs.opt, lhs.it_range, true };
                vector_variable_assign_initializer_list(ctx, lhs_opt, il);
            } else {
                if (il.empty())
                    ctx->throw_exception("Cannot create vector variable from an empty initializer list, because its type cannot be deduced.", lhs.it_range);
                // Allocate a new vector variable.
                // First guesstimate type of the output vector.
                size_t num_bool = 0;
                size_t num_int = 0;
                size_t num_double = 0;
                size_t num_string = 0;
                for (auto &i : il)
                    switch (i.type()) {
                    case expr::TYPE_BOOL:     ++ num_bool;    break;
                    case expr::TYPE_INT:      ++ num_int;     break;
                    case expr::TYPE_DOUBLE:   ++ num_double;  break;
                    case expr::TYPE_STRING:   ++ num_string;  break;
                    default: assert(false);
                    }
                std::unique_ptr<ConfigOption> opt_new;
                if (num_string > 0)
                    // Convert everything to strings.
                    opt_new = std::make_unique<ConfigOptionStrings>();
                else if (num_bool > 0) {
                    if (num_double + num_int > 0)
                        ctx->throw_exception("Right side is not valid: Mixing numeric and boolean types.", IteratorRange{ il.front().it_range.begin(), il.back().it_range.end() });
                    opt_new = std::make_unique<ConfigOptionBools>();
                } else {
                    // Output is numeric.
                    if (num_double == 0)
                        opt_new = std::make_unique<ConfigOptionInts>();
                    else 
                        opt_new = std::make_unique<ConfigOptionFloats>();
                }
                OptWithPos lhs_opt{ opt_new.get(), lhs.it_range, true };
                vector_variable_assign_initializer_list(ctx, lhs_opt, il);
                const_cast<MyContext*>(ctx)->store_new_variable(lhs.name, std::move(opt_new), global_variable);
            }
        }

References Slic3r::client::MyContext::NewOldVariable::it_range, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::client::MyContext::NewOldVariable::opt, skipping(), store_new_variable(), throw_exception(), Slic3r::client::expr::TYPE_BOOL, Slic3r::client::expr::TYPE_DOUBLE, Slic3r::client::expr::TYPE_INT, Slic3r::client::expr::TYPE_STRING, and vector_variable_assign_initializer_list().

Referenced by Slic3r::client::macro_processor::macro_processor().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ config

const DynamicConfig* Slic3r::client::MyContext::config = nullptr

Referenced by Slic3r::PlaceholderParser::evaluate_boolean_expression(), optptr(), and Slic3r::PlaceholderParser::process().

◆ config_local

DynamicConfig Slic3r::client::MyContext::config_local

mutable

Referenced by new_old_variable().

◆ config_outputs

DynamicConfig* Slic3r::client::MyContext::config_outputs = nullptr

mutable

Referenced by new_old_variable(), and Slic3r::PlaceholderParser::process().

◆ config_override

const DynamicConfig* Slic3r::client::MyContext::config_override = nullptr

Referenced by Slic3r::PlaceholderParser::evaluate_boolean_expression(), optptr(), and Slic3r::PlaceholderParser::process().

◆ context_data

PlaceholderParser::ContextData* Slic3r::client::MyContext::context_data = nullptr

Referenced by new_old_variable(), Slic3r::PlaceholderParser::process(), and random().

◆ current_extruder_id

size_t Slic3r::client::MyContext::current_extruder_id = 0

Referenced by legacy_variable_expansion(), Slic3r::PlaceholderParser::process(), and scalar_variable_to_expr().

◆ error_message

std::string Slic3r::client::MyContext::error_message

Referenced by process_error_message(), and Slic3r::process_macro().

◆ external_config

const DynamicConfig* Slic3r::client::MyContext::external_config = nullptr

Referenced by optptr(), and Slic3r::PlaceholderParser::process().

◆ just_boolean_expression

bool Slic3r::client::MyContext::just_boolean_expression = false

Referenced by Slic3r::PlaceholderParser::evaluate_boolean_expression(), and evaluate_full_macro().

◆ m_depth_suppressed

int Slic3r::client::MyContext::m_depth_suppressed { 0 }

mutableprivate

Referenced by block_enter(), block_exit(), block_exit_ternary(), and skipping().

◆ tag_to_error_message

std::map< std::string, std::string > Slic3r::client::MyContext::tag_to_error_message

static

Initial value:

= {
        { "eoi",                        "Unknown syntax error" },
        { "start",                      "Unknown syntax error" },
        { "text",                       "Invalid text." },
        { "text_block",                 "Invalid text block." },
        { "macro",                      "Invalid macro." },
        { "repeat",                     "Unknown syntax error" },
        { "if_else_output",             "Not an {if}{else}{endif} macro." },
        { "switch_output",              "Not a {switch} macro." },
        { "legacy_variable_expansion",  "Expecting a legacy variable expansion format" },
        { "identifier",                 "Expecting an identifier." },
        { "conditional_expression",     "Expecting a conditional expression." },
        { "logical_or_expression",      "Expecting a boolean expression." },
        { "logical_and_expression",     "Expecting a boolean expression." },
        { "equality_expression",        "Expecting an expression." },
        { "bool_expr_eval",             "Expecting a boolean expression."},
        { "relational_expression",      "Expecting an expression." },
        { "additive_expression",        "Expecting an expression." },
        { "multiplicative_expression",  "Expecting an expression." },
        { "unary_expression",           "Expecting an expression." },
        { "optional_parameter",         "Expecting a closing brace or an optional parameter." },
        { "one_of_list",                "Expecting a list of string patterns (simple text or rexep)" },
        { "variable_reference",         "Expecting a variable reference."},
        { "variable",                   "Expecting a variable name."},
        { "regular_expression",         "Expecting a regular expression."}
    }

Referenced by process_error_message().

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

src/libslic3r/PlaceholderParser.cpp

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Detailed Description

Class Documentation

◆ Slic3r::client::MyContext::NewOldVariable

Member Function Documentation

◆ block_enter()

◆ block_exit()

◆ block_exit_ternary()

◆ check_numeric()

◆ check_writable()

◆ copy_vector_variable_to_vector_variable()

◆ could_be_vector_variable_reference()

◆ evaluate_count()

◆ evaluate_full_macro()

◆ evaluate_index()

◆ fill_vector_from_initializer_list()

◆ has()

◆ initializer_list_append()

◆ is_nil_test()

◆ is_vector_empty()

◆ is_vector_variable_reference()

◆ legacy_variable_expansion()

◆ legacy_variable_expansion2()

◆ new_old_variable()

◆ option() [1/2]

◆ option() [2/2]

◆ option_throw() [1/2]

◆ option_throw() [2/2]

◆ optptr()

◆ process_error_message()

◆ random()

◆ resolve_output_symbol()

◆ resolve_symbol()

◆ resolve_variable()

◆ scalar_variable_assign_scalar()

◆ scalar_variable_assign_scalar_expression()

◆ scalar_variable_new_from_scalar_expression()

◆ scalar_variable_to_expr()

◆ skipping()

◆ store_new_variable()

◆ store_variable_index()

◆ throw_exception()

◆ variable_value()

◆ vector_element_to_expr()

◆ vector_size()

◆ vector_variable_assign_array()

◆ vector_variable_assign_expr_with_count()

◆ vector_variable_assign_initializer_list()

◆ vector_variable_element_assign_scalar()

◆ vector_variable_new_from_array()

◆ vector_variable_new_from_copy()

◆ vector_variable_new_from_initializer_list()

Member Data Documentation

◆ config

◆ config_local

◆ config_outputs

◆ config_override

◆ context_data

◆ current_extruder_id

◆ error_message

◆ external_config

◆ just_boolean_expression

◆ m_depth_suppressed

◆ tag_to_error_message