Slic3r::client::MyContext Struct Reference

Inheritance diagram for Slic3r::client::MyContext:

Collaboration diagram for Slic3r::client::MyContext:

Classes
struct	NewOldVariable

Public Member Functions
size_t	get_extruder_id () const
bool	skipping () const
bool	check_inactive_names () 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)
void	mark_deferred (expr &output) const
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	filament_change (const MyContext *ctx, expr &param)
static void	regex_replace (const MyContext *ctx, expr &subject, IteratorRange &pattern, expr &replacement)
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
std::set< std::string >	inactive_local_variables
const std::set< std::string > *	deferred_tags = nullptr

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()

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()

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()

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_inactive_names()

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

inline

{ return PlaceholderParser::check_inactive_branches && ! just_boolean_expression; }

References Slic3r::PlaceholderParser::check_inactive_branches, and just_boolean_expression.

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

Here is the caller graph for this function:

check_numeric()

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

inlinestatic

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

References L, 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()

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

inlinestatic

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

References L, and throw_exception().

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()

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(L("Cannot assign scalar to a vector"), lhs.it_range);
            if (rhs.opt->is_nil())
                ctx->throw_exception(L("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(L("Left hand side is a float vector, while the right hand side is not."), lhs.it_range);
                case coInts:
                    ctx->throw_exception(L("Left hand side is an int vector, while the right hand side is not."), lhs.it_range);
                case coStrings:
                    ctx->throw_exception(L("Left hand side is a string vector, while the right hand side is not."), lhs.it_range);
                case coBools:
                    ctx->throw_exception(L("Left hand side is a bool vector, while the right hand side is not."), lhs.it_range);
                default:
                    ctx->throw_exception(L("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, L, 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()

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()

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

inlinestatic

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

References count, Slic3r::client::expr::i(), L, 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()

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

inlinestatic

{ 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()

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(L("Non-integer index is not allowed to address a vector variable."));
                output = expr_index.i();
            }
        }

References Slic3r::client::expr::i(), L, 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:

filament_change()

void Slic3r::client::MyContext::filament_change ( const MyContext * ctx, expr & param )

inlinestatic

        {
            if (param.type() == expr::TYPE_EMPTY)
                // Inside an if / else block to be skipped
                return;
            MyContext *context = const_cast<MyContext *>(ctx);
            param.throw_if_deferred();
            context->current_extruder_id = param.as_i();
        }

References Slic3r::client::expr::as_i(), current_extruder_id, Slic3r::client::expr::throw_if_deferred(), 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:

fill_vector_from_initializer_list()

template<typename ConfigOptionType, typename RightValueEvaluate>

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));
        }

Referenced by vector_variable_assign_initializer_list().

Here is the caller graph for this function:

get_extruder_id()

size_t Slic3r::client::MyContext::get_extruder_id ( ) const

inline

                                       {
            if (external_config != nullptr) {
                const ConfigOptionInts * filament_map_opt = external_config->option<ConfigOptionInts>("filament_map");
                if (filament_map_opt && current_extruder_id < filament_map_opt->values.size()) {
                    return filament_map_opt->values[current_extruder_id];
                }
            }
            return 0;
        }

References current_extruder_id, external_config, Slic3r::ConfigOptionVector< int >::size(), and Slic3r::ConfigOptionVector< int >::values.

Referenced by vector_element_to_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

has()

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

inlineinherited

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

References optptr().

Referenced by Slic3r::_BBS_3MF_Exporter::_add_slice_info_config_file_to_archive(), Slic3r::active_bed_exclude_volume_mode(), Slic3r::append_bed_exclude_volumes(), Slic3r::append_printer_bed_assets(), Slic3r::GUI::change_opt_value(), Slic3r::GUI::ConfigManipulation::check_adaptive_pressure_advance_model(), Slic3r::GUI::PartPlateList::check_all_plate_local_bed_type(), Slic3r::GUI::ConfigManipulation::check_chamber_minimal_temperature(), Slic3r::GUI::ConfigManipulation::check_chamber_temperature(), Slic3r::GUI::ConfigManipulation::check_filament_max_volumetric_speed(), Slic3r::GUI::ConfigManipulation::check_nozzle_recommended_temperature_range(), Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_initial_layer_range(), Slic3r::GUI::ConfigManipulation::check_nozzle_temperature_range(), Slic3r::config_value_or_none(), Slic3r::GUI::Bed3D::detect_type(), Slic3r::PresetCollection::dirty_options(), Slic3r::PresetCollection::dirty_options_without_option_list(), Slic3r::GUI::ensure_belt_purge_tower(), Slic3r::extend_default_config_length(), Slic3r::extend_extruder_variant(), Slic3r::anonymous_namespace{PluginResolver.cpp}::find_option_for_capability(), Slic3r::get_bed_excluded_regions_by_extruder(), Slic3r::GUI::PartPlate::get_bed_type(), Slic3r::anonymous_namespace{SL1.cpp}::get_cfg_value(), Slic3r::GUI::GLGizmoBrimEars::get_config_options(), Slic3r::GUI::ConfigOptionsGroup::get_config_value(), Slic3r::GUI::get_formatted_tooltip_text(), Slic3r::get_instance_arrange_poly(), Slic3r::GUI::PartPlate::get_object_filament_extruders(), Slic3r::GUI::OrientJob::get_orient_mesh(), Slic3r::DynamicPrintConfig::get_parameter_size(), Slic3r::GUI::CalibrationPresetPage::get_print_preset(), Slic3r::GUI::PartPlate::get_spiral_vase_mode(), Slic3r::GUI::ConfigManipulation::get_temperature_range(), Slic3r::GUI::PresetComboBox::get_tooltip(), Slic3r::PrintConfigDef::handle_legacy_composite(), Slic3r::handle_legacy_project_loaded(), Slic3r::handle_legacy_sla(), Slic3r::has_bed_exclude_volumes(), Slic3r::PresetBundle::import_json_presets(), Slic3r::PresetCollection::is_dirty(), Slic3r::GUI::is_same_nozzle_type(), Slic3r::GUI::ObjectList::load_shape_object(), Slic3r::PresetCollection::load_user_preset(), Slic3r::DynamicPrintConfig::normalize_fdm(), Slic3r::DynamicPrintConfig::normalize_fdm_1(), Slic3r::GUI::PartPlateList::notify_instance_update(), Slic3r::GUI::TabPrintPlate::on_value_change(), Slic3r::DynamicConfig::read_cli(), Slic3r::Preset::remove_invalid_keys(), Slic3r::GUI::PartPlate::render_logo(), Slic3r::PresetBundle::resolve_vendor_preset(), Slic3r::CLI::run(), Slic3r::GUI::PartPlate::set_bed_type(), Slic3r::set_filament_dev_options(), Slic3r::Model::setExtruderParams(), Slic3r::Model::setPrintSpeedTable(), Slic3r::GUI::TabFilament::toggle_options(), Slic3r::GUI::ConfigManipulation::toggle_print_fff_options(), Slic3r::GLVolumeCollection::update_colors_by_extruder(), Slic3r::PresetBundle::update_compatible(), Slic3r::GUI::TabPrintPlate::update_custom_dirty(), Slic3r::GUI::TabPrintModel::update_model_config(), Slic3r::GUI::ConfigManipulation::update_print_fff_config(), and Slic3r::GUI::Tab::validate_filament_temperature_pairs().

Here is the call graph for this function:

initializer_list_append()

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()

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(L("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(L("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::ConfigOptionVectorBase::is_nil(), Slic3r::client::expr::it_range, L, 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()

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(L("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::expr::it_range, L, 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()

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()

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

inlinestatic

        {
            if (ctx->skipping() && ! ctx->check_inactive_names())
                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(L("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(L("Invalid vector index"), IteratorRange(opt_key.begin() + idx + 1, opt_key.end()));
                    }
                }
            }
            if (opt == nullptr)
                ctx->throw_exception(ctx->skipping() ? L("Variable does not exist (in an inactive branch)") : L("Variable does not exist"), opt_key);
            if (ctx->skipping())
                return;
            if (opt->is_scalar()) {
                if (opt->is_nil())
                    ctx->throw_exception(L("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(L("Indexing an empty vector variable"), opt_key);
                if (idx >= vec->size())
                    idx = 0;
                if (vec->is_nil(idx))
                    ctx->throw_exception(L("Trying to reference an undefined (nil) element of vector of optional values"), opt_key);
                output = vec->vserialize()[idx];
            }
        }

References check_inactive_names(), current_extruder_id, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::ConfigOptionVectorBase::is_nil(), L, resolve_symbol(), 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()

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

inlinestatic

        {
            if (ctx->skipping() && ! ctx->check_inactive_names())
                return;
 
            const char         *not_found = ctx->skipping() ? L("Variable does not exist (in an inactive branch)") : L("Variable does not exist");
            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(not_found, opt_key);
            }
            if (! opt->is_vector())
                ctx->throw_exception(L("Trying to index a scalar 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(not_found, opt_key);
            if (opt_index->type() != coInt)
                ctx->throw_exception(L("Indexing variable has to be integer"), opt_key);
            if (ctx->skipping())
                return;
            const ConfigOptionVectorBase *vec = static_cast<const ConfigOptionVectorBase*>(opt);
            if (vec->empty())
                ctx->throw_exception(L("Indexing an empty vector variable"), opt_key);
      int idx = opt_index->getInt();
      if (idx < 0)
                ctx->throw_exception(L("Negative vector index"), opt_key);
            if (idx >= (int)vec->size())
                idx = 0;
            if (vec->is_nil(idx))
                ctx->throw_exception(L("Trying to reference an undefined (nil) element of vector of optional values"), opt_key);
      output = vec->vserialize()[idx];
        }

References check_inactive_names(), Slic3r::coInt, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::ConfigOption::getInt(), Slic3r::ConfigOptionVectorBase::is_nil(), L, 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:

mark_deferred()

void Slic3r::client::MyContext::mark_deferred ( expr & output ) const

inline

                                                                  {
            if (output.type() != expr::TYPE_STRING)
                return;
            expr::Deferred deferred = expr::Deferred::None;
            if (deferred_tags != nullptr && output.s().find('@') != std::string::npos)
                for (const std::string &tag : *deferred_tags)
                    if (output.s().find(tag) != std::string::npos) {
                        deferred = output.s() == tag ? expr::Deferred::Value : expr::Deferred::Text;
                        break;
                    }
            output.set_deferred(deferred);
        }

References deferred_tags, Slic3r::client::expr::None, Slic3r::client::expr::s(), Slic3r::client::expr::set_deferred(), Slic3r::client::expr::Text, Slic3r::client::expr::type(), Slic3r::client::expr::TYPE_STRING, and Slic3r::client::expr::Value.

Referenced by regex_replace(), and variable_value().

Here is the call graph for this function:

Here is the caller graph for this function:

new_old_variable()

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(L("Symbol is already defined in read-only system dictionary"), it_range);
                if (ctx->config_outputs && ctx->config_outputs->optptr(key))
                    ctx->throw_exception(L("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(L("Global variables are not available in this context"), it_range);
                    if (ctx->config_local.optptr(key))
                        ctx->throw_exception(L("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(L("Variable name already defined in global scope"), it_range);
                    out.opt = ctx->config_local.optptr(key);
                }
                out.name     = std::move(key);
            } else if (ctx->check_inactive_names()) {
                // Declared in a branch that is not taken: the name still counts as defined for the names that follow.
                std::string key(it_range.begin(), it_range.end());
                if (global_variable && ctx->context_data != nullptr)
                    ctx->context_data->inactive_global_variables.insert(std::move(key));
                else
                    ctx->inactive_local_variables.insert(std::move(key));
            }
            out.it_range = it_range;
        }

References check_inactive_names(), config_local, config_outputs, context_data, Slic3r::PlaceholderParser::ContextData::global_config, Slic3r::PlaceholderParser::ContextData::inactive_global_variables, inactive_local_variables, Slic3r::client::MyContext::NewOldVariable::it_range, L, 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]

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 optptr().

Here is the call graph for this function:

option() [2/2]

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

inlineinherited

{ return this->optptr(opt_key); }

References 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_throw() [1/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 option_throw().

Here is the call graph for this function:

option_throw() [2/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 optptr().

Referenced by option_throw().

Here is the call graph for this function:

Here is the caller 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, and external_config.

Referenced by resolve_symbol().

Here is the caller graph for this function:

process_error_message()

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;
            if (! info.tag.empty() && info.tag.front() == '*') {
                // The gat contains an explanatory string.
                // TRN Custom G-code error. %1% is the line number, %2% the reason.
                msg += Slic3r::format(_u8L("Parsing error at line %1%: %2%"), line_nr, Slic3r::I18N::translate(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.
                    // TRN Custom G-code error. %1% is the line number, %2% the name of a grammar rule.
                    msg += Slic3r::format(_u8L("Parsing error at line %1%. Expecting tag %2%"), line_nr, info.tag);
                } else {
                    // Use the human readable error message.
                    // TRN Custom G-code error. %1% is the line number, %2% the reason.
                    msg += Slic3r::format(_u8L("Parsing error at line %1%. %2%"), line_nr, Slic3r::I18N::translate(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';
            // The error dialog (MsgDialog.cpp) renders this excerpt monospaced. It recognizes a source
            // line directly above a caret line of spaces and a single '^'.
            for (size_t i = 0; i < error_pos; ++ i)
                msg += ' ';
            msg += "^\n";
        }

References _u8L, error_message, Slic3r::format(), tag_to_error_message, and Slic3r::I18N::translate().

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()

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(L("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, L, 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:

regex_replace()

void Slic3r::client::MyContext::regex_replace ( const MyContext * ctx, expr & subject, IteratorRange & pattern, expr & replacement )

inlinestatic

        {
            expr::regex_replace(subject, pattern, replacement);
            ctx->mark_deferred(subject);
        }

References mark_deferred(), and Slic3r::client::expr::regex_replace().

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

{ return this->optptr(opt_key); }

References optptr().

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

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_variable()

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(L("Not a variable name"), opt_key);
                    output.writable = true;
                }
                output.opt = opt;
            } else if (ctx->check_inactive_names()) {
                // Only check the name. Back tracking may resolve the same identifier twice, so there are no side effects.
                const std::string key{ opt_key.begin(), opt_key.end() };
                if (ctx->resolve_symbol(key) == nullptr && ctx->resolve_output_symbol(key) == nullptr &&
                    ctx->inactive_local_variables.count(key) == 0 &&
                    (ctx->context_data == nullptr || ctx->context_data->inactive_global_variables.count(key) == 0))
                    ctx->throw_exception(L("Not a variable name (in an inactive branch)"), opt_key);
            }
            output.it_range = opt_key;
        }

References check_inactive_names(), context_data, Slic3r::PlaceholderParser::ContextData::inactive_global_variables, inactive_local_variables, Slic3r::client::OptWithPos::it_range, L, 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()

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(L("Right side is not a boolean expression"), rhs.it_range);
                static_cast<ConfigOptionBool*>(wropt)->value = rhs.b();
                break;
            default:
                ctx->throw_exception(L("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::expr::it_range, Slic3r::client::OptWithPos::it_range, L, 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()

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(), 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()

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())
                    ctx->throw_exception(L("Cannot assign a scalar value to a vector variable."), rhs.it_range);
                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);
            }
        }

References Slic3r::client::expr::b(), Slic3r::client::expr::d(), Slic3r::client::expr::i(), Slic3r::ConfigOption::is_vector(), Slic3r::client::expr::it_range, Slic3r::client::MyContext::NewOldVariable::it_range, L, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::client::MyContext::NewOldVariable::opt, Slic3r::client::expr::s(), scalar_variable_assign_scalar(), skipping(), store_new_variable(), throw_exception(), Slic3r::client::expr::type(), Slic3r::client::expr::TYPE_BOOL, Slic3r::client::expr::TYPE_DOUBLE, Slic3r::client::expr::TYPE_INT, and Slic3r::client::expr::TYPE_STRING.

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()

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(L("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, "line_width")) {
                    // Line 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(L("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies"), opt.it_range);
                  if (boost::ends_with(opt_def->ratio_over, "line_width")) {
                        // Line 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(L("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::ConfigOption::getFloat(), L, Slic3r::ConfigOptionFloatOrPercent::percent, Slic3r::print_config_def, Slic3r::ConfigOptionDef::ratio_over, resolve_symbol(), 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

{ return m_depth_suppressed > 0; }

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()

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

inlinestatic

        {
            if (! ctx->skipping()) {
                if (index < 0)
                    index = 0; // Orca: fallback to first element if index < 0, this matches the behavior of BambuStudio
                if (!opt.opt->is_vector())
                    index = -1; // Orca: ignore the index if variable is scalar, this matches the behavior of BambuStudio
                output = opt;
                output.index = index;
            } else
                output = opt;
            output.it_range.end()   = it_end;
        }

References Slic3r::client::OptWithPos::index, Slic3r::client::OptWithPos::it_range, 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:

throw_exception()

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::ascii_char_skipper_parser::parse(), Slic3r::client::utf8_char_parser::parse(), random(), resolve_variable(), scalar_variable_assign_scalar(), scalar_variable_new_from_scalar_expression(), scalar_variable_to_expr(), Slic3r::client::FactorActions::string_(), vector_element_to_expr(), vector_size(), vector_variable_assign_array(), 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:

variable_value()

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);
                ctx->mark_deferred(output);
            }
            output.it_range = opt.it_range;
        }

References Slic3r::client::expr::it_range, mark_deferred(), 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()

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());
            const ConfigOptionVectorBase* vec = static_cast<const ConfigOptionVectorBase*>(opt.opt);
            if (vec->empty())
                ctx->throw_exception(L("Indexing an empty vector variable"), opt.it_range);
 
            // Helper to resolve a FloatOrPercent value (handles ratio_over chain for percent values).
            // elem_index: the element index used to access this vector element, so that
            // parent vectors (via ratio_over) use the same index rather than the current extruder.
            auto resolve_float_or_percent = [ctx, &opt, &output](const FloatOrPercent &fop, size_t elem_index) {
                std::string opt_key(opt.it_range.begin(), opt.it_range.end());
                if (boost::ends_with(opt_key, "line_width")) {
                    // Line 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 (! fop.percent) {
                    // Not a percent, just return the value.
                    output.set_d(fop.value);
                } 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 = fop.value * 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(L("FloatOrPercent variable failed to resolve the \"ratio_over\" dependencies"), opt.it_range);
                        if (boost::ends_with(opt_def->ratio_over, "line_width")) {
                            // Line 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
                        } else if (opt_parent->type() == coFloats) {
                            // Vector parent: extract the value for the current extruder.
                            const ConfigOptionFloatsNullable *parent_nullable = dynamic_cast<const ConfigOptionFloatsNullable *>(opt_parent);
                            if (parent_nullable) {
                                v *= (parent_nullable->size() == 1) ? parent_nullable->get_at(0) : parent_nullable->get_at(elem_index);
                            } else {
                                const ConfigOptionFloats *parent_vec = static_cast<const ConfigOptionFloats *>(opt_parent);
                                v *= (parent_vec->size() == 1) ? parent_vec->get_at(0) : parent_vec->get_at(elem_index);
                            }
                            break;
                        } else if (opt_parent->type() == coFloatsOrPercents) {
                            // Vector parent with percent support: extract the FloatOrPercent for the current extruder.
                            const ConfigOptionFloatsOrPercentsNullable *parent_nullable = dynamic_cast<const ConfigOptionFloatsOrPercentsNullable *>(opt_parent);
                            if (parent_nullable) {
                                const FloatOrPercent &parent_fop = (parent_nullable->size() == 1) ? parent_nullable->get_at(0) : parent_nullable->get_at(elem_index);
                                if (! parent_fop.percent) {
                                    v *= parent_fop.value;
                                    break;
                                }
                                v *= parent_fop.value * 0.01; // percent to ratio
                            } else {
                                const ConfigOptionFloatsOrPercents *parent_vec = static_cast<const ConfigOptionFloatsOrPercents *>(opt_parent);
                                const FloatOrPercent &parent_fop = (parent_vec->size() == 1) ? parent_vec->get_at(0) : parent_vec->get_at(elem_index);
                                if (! parent_fop.percent) {
                                    v *= parent_fop.value;
                                    break;
                                }
                                v *= parent_fop.value * 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);
                }
            };
 
            if (!opt.has_index()) {
                // Allow omitting extruder id when referencing vectors
                switch (opt.opt->type()) {
                case coFloats: {
                    const ConfigOptionFloatsNullable* opt_floatsnullable = dynamic_cast<const ConfigOptionFloatsNullable *>(opt.opt);
                    if (opt_floatsnullable) {
                        if (opt_floatsnullable->size() == 1) { // old version
                            output.set_d(opt_floatsnullable->get_at(0));
                        } else {
                            output.set_d(opt_floatsnullable->get_at(ctx->get_extruder_id()));
                        }
                    } else {
                        const ConfigOptionFloats* opt_floats = static_cast<const ConfigOptionFloats*>(opt.opt);
                        if (opt_floats->size() == 1) { // old version
                            output.set_d(opt_floats->get_at(0));
                        } else {
                            output.set_d(opt_floats->get_at(ctx->get_extruder_id()));
                        }
                    }
                    break;
                }
                case coFloatsOrPercents: {
                    const ConfigOptionFloatsOrPercentsNullable *opt_vec_nullable = dynamic_cast<const ConfigOptionFloatsOrPercentsNullable *>(opt.opt);
                    if (opt_vec_nullable) {
                        size_t elem_index = (opt_vec_nullable->size() == 1) ? 0 : ctx->get_extruder_id();
                        resolve_float_or_percent(opt_vec_nullable->get_at(elem_index), elem_index);
                    } else {
                        const ConfigOptionFloatsOrPercents *opt_vec = static_cast<const ConfigOptionFloatsOrPercents *>(opt.opt);
                        size_t elem_index = (opt_vec->size() == 1) ? 0 : ctx->get_extruder_id();
                        resolve_float_or_percent(opt_vec->get_at(elem_index), elem_index);
                    }
                    break;
                }
                default: ctx->throw_exception(L("Referencing a vector variable when scalar is expected"), opt.it_range);
                }
            } else {
                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(L("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_i(static_cast<const ConfigOptionInts    *>(opt.opt)->values[idx]); break;
                case coFloatsOrPercents: {
                    const ConfigOptionFloatsOrPercentsNullable *opt_vec_nullable = dynamic_cast<const ConfigOptionFloatsOrPercentsNullable *>(opt.opt);
                    if (opt_vec_nullable) {
                        resolve_float_or_percent(opt_vec_nullable->values[idx], idx);
                    } else {
                        resolve_float_or_percent(static_cast<const ConfigOptionFloatsOrPercents *>(opt.opt)->values[idx], idx);
                    }
                    break;
                }
                default:
                    ctx->throw_exception(L("Unsupported vector variable type"), opt.it_range);
                }
            }
        }

References Slic3r::coBools, Slic3r::coEnums, Slic3r::coFloat, Slic3r::coFloatOrPercent, Slic3r::coFloats, Slic3r::coFloatsOrPercents, Slic3r::coInts, Slic3r::coPercents, Slic3r::coPoints, Slic3r::coStrings, current_extruder_id, Slic3r::ConfigOptionVectorBase::empty(), Slic3r::Flow::extrusion_width(), Slic3r::ConfigOptionVector< double >::get_at(), Slic3r::ConfigOptionVector< FloatOrPercent >::get_at(), get_extruder_id(), Slic3r::ConfigOption::getFloat(), Slic3r::ConfigOptionVectorBase::is_nil(), L, Slic3r::ConfigOptionFloatOrPercent::percent, Slic3r::FloatOrPercent::percent, Slic3r::print_config_def, Slic3r::ConfigOptionDef::ratio_over, resolve_symbol(), Slic3r::client::expr::set_b(), Slic3r::client::expr::set_d(), Slic3r::client::expr::set_i(), Slic3r::client::expr::set_s(), Slic3r::ConfigOptionVector< double >::size(), Slic3r::ConfigOptionVector< FloatOrPercent >::size(), Slic3r::ConfigOptionVectorBase::size(), skipping(), throw_exception(), Slic3r::to_string(), Slic3r::ConfigOption::type(), Slic3r::FloatOrPercent::value, Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< FloatOrPercent >::values.

Referenced by variable_value().

Here is the call graph for this function:

Here is the caller graph for this function:

vector_size()

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(L("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::expr::it_range, L, 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()

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())
                    ctx->throw_exception(L("Cannot assign a vector value to a scalar variable."), rhs_value.it_range);
                vector_variable_assign_expr_with_count(ctx, lhs, rhs_count, rhs_value);
            }
        }

References check_writable(), Slic3r::ConfigOption::is_scalar(), Slic3r::client::expr::it_range, L, Slic3r::client::OptWithPos::opt, skipping(), 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()

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(L("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, count, evaluate_count(), L, 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()

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(L("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(L("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(L("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, fill_vector_from_initializer_list(), Slic3r::ConfigOption::is_scalar(), Slic3r::client::OptWithPos::it_range, L, 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()

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(L("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(L("Indexing an empty vector variable"), lhs.it_range);
            if (lhs.index >= int(vec->size()))
                ctx->throw_exception(L("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(L("Right side is not a boolean expression"), rhs.it_range);
                static_cast<ConfigOptionBools*>(vec)->values[lhs.index] = rhs.b();
                break;
            default:
                ctx->throw_exception(L("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::expr::it_range, Slic3r::client::OptWithPos::it_range, L, 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()

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())
                    ctx->throw_exception(L("Cannot assign a vector value to a scalar variable."), rhs_value.it_range);
                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);
            }
        }

References Slic3r::client::expr::b(), count, Slic3r::client::expr::d(), evaluate_count(), Slic3r::client::expr::i(), Slic3r::ConfigOption::is_scalar(), Slic3r::client::expr::it_range, Slic3r::client::MyContext::NewOldVariable::it_range, L, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::client::MyContext::NewOldVariable::opt, Slic3r::client::expr::s(), skipping(), store_new_variable(), throw_exception(), Slic3r::client::expr::type(), Slic3r::client::expr::TYPE_BOOL, Slic3r::client::expr::TYPE_DOUBLE, Slic3r::client::expr::TYPE_INT, Slic3r::client::expr::TYPE_STRING, 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_new_from_copy()

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, let conditional_expression parse the whole right hand side, which may continue after the variable reference.
                return false;
 
            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(L("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(L("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::MyContext::NewOldVariable::it_range, Slic3r::client::OptWithPos::it_range, L, Slic3r::client::MyContext::NewOldVariable::name, Slic3r::one_of(), Slic3r::client::MyContext::NewOldVariable::opt, Slic3r::client::OptWithPos::opt, skipping(), store_new_variable(), throw_exception(), and Slic3r::ConfigOption::type().

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()

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(L("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(L("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, L, 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(), random(), and resolve_variable().

current_extruder_id

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

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

deferred_tags

const std::set<std::string>* Slic3r::client::MyContext::deferred_tags = nullptr

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

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 get_extruder_id(), optptr(), and Slic3r::PlaceholderParser::process().

inactive_local_variables

std::set<std::string> Slic3r::client::MyContext::inactive_local_variables

mutable

Referenced by new_old_variable(), and resolve_variable().

just_boolean_expression

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

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

m_depth_suppressed

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

mutableprivate

{ 0 };

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

Referenced by process_error_message().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/PlaceholderParser.cpp