Slic3r::GCodeReader Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCodeReader.hpp>

Collaboration diagram for Slic3r::GCodeReader:

Classes
class	GCodeLine

Public Types
typedef std::function< void(GCodeReader &, const GCodeLine &)>	callback_t
typedef std::function< void(GCodeReader &, const char *, const char *)>	raw_line_callback_t

Public Member Functions
	GCodeReader ()
void	reset ()
void	apply_config (const GCodeConfig &config)
void	apply_config (const DynamicPrintConfig &config)
const GCodeConfig &	config ()
template<typename Callback>
void	parse_buffer (const std::string &buffer, Callback callback)
void	parse_buffer (const std::string &buffer)
template<typename Callback>
const char *	parse_line (const char *ptr, const char *end, GCodeLine &gline, Callback &callback)
template<typename Callback>
void	parse_line (const std::string &line, Callback callback)
bool	parse_file (const std::string &file, callback_t callback)
bool	parse_file (const std::string &file, callback_t callback, std::vector< size_t > &lines_ends)
bool	parse_file_raw (const std::string &file, raw_line_callback_t callback)
void	quit_parsing ()
float &	x ()
float	x () const
float &	y ()
float	y () const
float &	z ()
float	z () const
float &	e ()
float	e () const
float &	f ()
float	f () const
float &	i ()
float	i () const
float &	j ()
float	j () const
GCodeConfig	get_config () const

Private Member Functions
template<typename ParseLineCallback, typename LineEndCallback>
bool	parse_file_raw_internal (const std::string &filename, ParseLineCallback parse_line_callback, LineEndCallback line_end_callback)
template<typename ParseLineCallback, typename LineEndCallback>
bool	parse_file_internal (const std::string &filename, ParseLineCallback parse_line_callback, LineEndCallback line_end_callback)
const char *	parse_line_internal (const char *ptr, const char *end, GCodeLine &gline, std::pair< const char *, const char * > &command)
void	update_coordinates (GCodeLine &gline, std::pair< const char *, const char * > &command)

Static Private Member Functions
static bool	is_whitespace (char c)
static bool	is_end_of_line (char c)
static bool	is_end_of_gcode_line (char c)
static bool	is_end_of_word (char c)
static const char *	skip_whitespaces (const char *c)
static const char *	skip_word (const char *c)
static const char *	axis_pos (const char *raw_str, char axis)
static const GCodeConfig &	default_config ()

Private Attributes
std::shared_ptr< const GCodeConfig >	m_config
bool	m_use_relative_e_distances { default_config().use_relative_e_distances.value }
float	m_position [NUM_AXES]
bool	m_verbose
bool	m_parsing { false }

Detailed Description

Member Typedef Documentation

callback_t

typedef std::function<void(GCodeReader&, const GCodeLine&)> Slic3r::GCodeReader::callback_t

raw_line_callback_t

typedef std::function<void(GCodeReader&, const char*, const char*)> Slic3r::GCodeReader::raw_line_callback_t

Constructor & Destructor Documentation

GCodeReader()

Slic3r::GCodeReader::GCodeReader ( )

inline

: m_verbose(false) { this->reset(); }

References m_verbose, and reset().

Referenced by parse_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

apply_config() [1/2]

void Slic3r::GCodeReader::apply_config

(

const DynamicPrintConfig &

config

)

{
    auto applied = std::make_shared<GCodeConfig>(m_config ? *m_config : default_config());
    applied->apply(config, true);
    m_use_relative_e_distances = applied->use_relative_e_distances.value;
    m_config                   = std::move(applied);
}

References config(), default_config(), m_config, and m_use_relative_e_distances.

Here is the call graph for this function:

apply_config() [2/2]

void Slic3r::GCodeReader::apply_config

(

const GCodeConfig &

config

)

{
    m_config                   = std::make_shared<const GCodeConfig>(config);
    m_use_relative_e_distances = config.use_relative_e_distances.value;
}

References config(), Slic3r::GCodeConfig, m_config, and m_use_relative_e_distances.

Here is the call graph for this function:

axis_pos()

const char * Slic3r::GCodeReader::axis_pos ( const char * raw_str, char axis )

staticprivate

{
    const char *c = raw_str;
    // Skip the whitespaces.
    c = skip_whitespaces(c);
    // Skip the command.
    c = skip_word(c);
    // Up to the end of line or comment.
    while (! is_end_of_gcode_line(*c)) {
        // Skip whitespaces.
        c = skip_whitespaces(c);
        if (is_end_of_gcode_line(*c))
            break;
        // Check the name of the axis.
        if (*c == axis)
            return c;
        // Skip the rest of the word.
        c = skip_word(c);
    }
    return nullptr;
}

References is_end_of_gcode_line(), skip_whitespaces(), and skip_word().

Referenced by Slic3r::GCodeReader::GCodeLine::axis_pos().

Here is the call graph for this function:

Here is the caller graph for this function:

config()

const GCodeConfig & Slic3r::GCodeReader::config ( )

inline

{ return m_config ? *m_config : default_config(); };

References default_config(), Slic3r::GCodeConfig, and m_config.

Referenced by apply_config(), apply_config(), and default_config().

Here is the call graph for this function:

Here is the caller graph for this function:

default_config()

const GCodeConfig & Slic3r::GCodeReader::default_config ( )

staticprivate

{
    static const GCodeConfig config;
    return config;
}

References config(), and Slic3r::GCodeConfig.

Referenced by apply_config(), config(), and get_config().

Here is the call graph for this function:

Here is the caller graph for this function:

e() [1/2]

float & Slic3r::GCodeReader::e ( )

inline

{ return m_position[E]; }

References Slic3r::E, and m_position.

Referenced by Slic3r::FanMover::_process_gcode_line(), Slic3r::GCodeReader::GCodeLine::dist_E(), and Slic3r::GCodeReader::GCodeLine::new_E().

Here is the caller graph for this function:

e() [2/2]

float Slic3r::GCodeReader::e ( ) const

inline

{ return m_position[E]; }

References Slic3r::E, and m_position.

f() [1/2]

float & Slic3r::GCodeReader::f ( )

inline

{ return m_position[F]; }

References Slic3r::F, and m_position.

Referenced by Slic3r::GCodeReader::GCodeLine::new_F().

Here is the caller graph for this function:

f() [2/2]

float Slic3r::GCodeReader::f ( ) const

inline

{ return m_position[F]; }

References Slic3r::F, and m_position.

get_config()

GCodeConfig Slic3r::GCodeReader::get_config ( ) const

inline

    { 
        return m_config ? *m_config : default_config();
    }

References default_config(), Slic3r::GCodeConfig, and m_config.

Here is the call graph for this function:

i() [1/2]

float & Slic3r::GCodeReader::i ( )

inline

{ return m_position[I]; }

References Slic3r::I, and m_position.

Referenced by update_coordinates().

Here is the caller graph for this function:

i() [2/2]

float Slic3r::GCodeReader::i ( ) const

inline

{ return m_position[I]; }

References Slic3r::I, and m_position.

is_end_of_gcode_line()

bool Slic3r::GCodeReader::is_end_of_gcode_line ( char c )

inlinestaticprivate

{ return c == ';' || is_end_of_line(c); }

References is_end_of_line().

Referenced by axis_pos(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), is_end_of_word(), and parse_line_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

is_end_of_line()

bool Slic3r::GCodeReader::is_end_of_line ( char c )

inlinestaticprivate

{ return c == '\r' || c == '\n' || c == 0; }

Referenced by is_end_of_gcode_line(), and parse_line_internal().

Here is the caller graph for this function:

is_end_of_word()

bool Slic3r::GCodeReader::is_end_of_word ( char c )

inlinestaticprivate

{ return is_whitespace(c) || is_end_of_gcode_line(c); }

References is_end_of_gcode_line(), and is_whitespace().

Referenced by Slic3r::GCodeReader::GCodeLine::cmd_is(), Slic3r::GCodeReader::GCodeLine::has_value(), Slic3r::GCodeReader::GCodeLine::has_value(), parse_line_internal(), and skip_word().

Here is the call graph for this function:

Here is the caller graph for this function:

is_whitespace()

bool Slic3r::GCodeReader::is_whitespace ( char c )

inlinestaticprivate

{ return c == ' ' || c == '\t'; }

Referenced by is_end_of_word(), and skip_whitespaces().

Here is the caller graph for this function:

j() [1/2]

float & Slic3r::GCodeReader::j ( )

inline

{ return m_position[J]; }

References Slic3r::J, and m_position.

j() [2/2]

float Slic3r::GCodeReader::j ( ) const

inline

{ return m_position[J]; }

References Slic3r::J, and m_position.

parse_buffer() [1/2]

void Slic3r::GCodeReader::parse_buffer ( const std::string & buffer )

inline

        { this->parse_buffer(buffer, [](GCodeReader&, const GCodeReader::GCodeLine&){}); }

References GCodeReader(), and parse_buffer().

Here is the call graph for this function:

parse_buffer() [2/2]

template<typename Callback>

void Slic3r::GCodeReader::parse_buffer ( const std::string & buffer, Callback callback )

inline

    {
        const char *ptr = buffer.c_str();
        const char *end = ptr + buffer.size();
        GCodeLine gline;
        m_parsing = true;
        while (m_parsing && *ptr != 0) {
            gline.reset();
            ptr = this->parse_line(ptr, end, gline, callback);
        }
    }

References m_parsing, parse_line(), and Slic3r::GCodeReader::GCodeLine::reset().

Referenced by Slic3r::GCodeProcessor::contains_reserved_tag(), Slic3r::GCodeProcessor::contains_reserved_tags(), Slic3r::custom_gcode_motion_state_changes(), Slic3r::anonymous_namespace{GCode.cpp}::emitted_xy_after_gcode(), parse_buffer(), and Slic3r::SpiralVase::process_layer().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_file() [1/2]

bool Slic3r::GCodeReader::parse_file	(	const std::string &	file,
		callback_t	callback )

{
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  before parse_file %1%") % file.c_str();
    auto ret = this->parse_file_internal(file, callback, [](size_t) {});
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  finished parse_file %1%") % file.c_str();
 
    return ret;
}

References parse_file_internal().

Here is the call graph for this function:

parse_file() [2/2]

bool Slic3r::GCodeReader::parse_file	(	const std::string &	file,
		callback_t	callback,
		std::vector< size_t > &	lines_ends )

{
    lines_ends.clear();
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  before parse_file %1%") % file.c_str();
    auto ret = this->parse_file_internal(file, callback, [&lines_ends](size_t file_pos){ lines_ends.emplace_back(file_pos); });
    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(":  finished parse_file %1%") % file.c_str();
 
    return ret;
}

References parse_file_internal().

Here is the call graph for this function:

parse_file_internal()

template<typename ParseLineCallback, typename LineEndCallback>

bool Slic3r::GCodeReader::parse_file_internal ( const std::string & filename, ParseLineCallback parse_line_callback, LineEndCallback line_end_callback )

private

{
    GCodeLine gline;    
    return this->parse_file_raw_internal(filename, 
        [this, &gline, parse_line_callback](const char *begin, const char *end) {
            gline.reset();
 
            const char* begin_new = begin;
            begin_new = skip_whitespaces(begin_new);
            if (std::toupper(*begin_new) == 'N')
                begin_new = skip_word(begin_new);
            begin_new = skip_whitespaces(begin_new);
            this->parse_line(begin_new, end, gline, parse_line_callback);
        }, 
        line_end_callback);
}

References parse_file_raw_internal(), parse_line(), Slic3r::GCodeReader::GCodeLine::reset(), skip_whitespaces(), and skip_word().

Referenced by parse_file(), and parse_file().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_file_raw()

bool Slic3r::GCodeReader::parse_file_raw	(	const std::string &	file,
		raw_line_callback_t	callback )

{
    return this->parse_file_raw_internal(filename,
        [this, line_callback](const char *begin, const char *end) { line_callback(*this, begin, end); }, 
        [](size_t){});
}

References parse_file_raw_internal().

Here is the call graph for this function:

parse_file_raw_internal()

template<typename ParseLineCallback, typename LineEndCallback>

bool Slic3r::GCodeReader::parse_file_raw_internal ( const std::string & filename, ParseLineCallback parse_line_callback, LineEndCallback line_end_callback )

private

{
    FilePtr in{ boost::nowide::fopen(filename.c_str(), "rb") };
 
    // Read the input stream 64kB at a time, extract lines and process them.
    std::vector<char> buffer(65536 * 10, 0);
    // Line buffer.
    std::string gcode_line;
    size_t file_pos = 0;
    m_parsing = true;
    for (;;) {
        size_t cnt_read = ::fread(buffer.data(), 1, buffer.size(), in.f);
        if (::ferror(in.f))
            return false;
        bool eof       = cnt_read == 0;
        auto it        = buffer.begin();
        auto it_bufend = buffer.begin() + cnt_read;
        while (it != it_bufend || (eof && ! gcode_line.empty())) {
            // Find end of line.
            bool eol    = false;
            auto it_end = it;
            for (; it_end != it_bufend && ! (eol = *it_end == '\r' || *it_end == '\n'); ++ it_end)
                if (*it_end == '\n')
                    line_end_callback(file_pos + (it_end - buffer.begin()) + 1);
            // End of line is indicated also if end of file was reached.
            eol |= eof && it_end == it_bufend;
            if (eol) {
                if (gcode_line.empty())
                    parse_line_callback(&(*it), &(*it_end));
                else {
                    gcode_line.insert(gcode_line.end(), it, it_end);
                    parse_line_callback(gcode_line.c_str(), gcode_line.c_str() + gcode_line.size());
                    gcode_line.clear();
                }
                if (! m_parsing)
                    // The callback wishes to exit.
                    return true;
            } else
                gcode_line.insert(gcode_line.end(), it, it_end);
            // Skip EOL.
            it = it_end; 
            if (it != it_bufend && *it == '\r')
                ++ it;
            if (it != it_bufend && *it == '\n') {
                line_end_callback(file_pos + (it - buffer.begin()) + 1);
                ++ it;
            }
        }
        if (eof)
            break;
        file_pos += cnt_read;
    }
    return true;
}

References Slic3r::FilePtr::f, and m_parsing.

Referenced by parse_file_internal(), and parse_file_raw().

Here is the caller graph for this function:

parse_line() [1/2]

template<typename Callback>

const char * Slic3r::GCodeReader::parse_line ( const char * ptr, const char * end, GCodeLine & gline, Callback & callback )

inline

    {
        std::pair<const char*, const char*> cmd;
        const char *line_end = parse_line_internal(ptr, end, gline, cmd);
        callback(*this, gline);
        update_coordinates(gline, cmd);
        return line_end;
    }

References parse_line_internal(), and update_coordinates().

Referenced by parse_buffer(), parse_file_internal(), parse_line(), Slic3r::GCodeProcessor::process_G28(), Slic3r::GCodeProcessor::process_gcode_line(), and Slic3r::GCodeProcessor::run_post_process().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_line() [2/2]

template<typename Callback>

void Slic3r::GCodeReader::parse_line ( const std::string & line, Callback callback )

inline

        { GCodeLine gline; this->parse_line(line.c_str(), line.c_str() + line.size(), gline, callback); }

References parse_line().

Here is the call graph for this function:

parse_line_internal()

const char * Slic3r::GCodeReader::parse_line_internal ( const char * ptr, const char * end, GCodeLine & gline, std::pair< const char *, const char * > & command )

private

{
    PROFILE_FUNC();
 
    assert(is_decimal_separator_point());
    
    // command and args
    const char *c = ptr;
    {
        PROFILE_BLOCK(command_and_args);
        // Skip the whitespaces.
        command.first = skip_whitespaces(c);
        // Skip the command.
        c = command.second = skip_word(command.first);
        // Up to the end of line or comment.
    while (! is_end_of_gcode_line(*c)) {
            // Skip whitespaces.
            c = skip_whitespaces(c);
      if (is_end_of_gcode_line(*c))
        break;
            // Check the name of the axis.
            Axis axis = NUM_AXES_WITH_UNKNOWN;
            switch (*c) {
            case 'X': axis = X; break;
            case 'Y': axis = Y; break;
            case 'Z': axis = Z; break;
            case 'F': axis = F; break;
            //BBS: add I and J axis
            case 'I': axis = I; break;
            case 'J': axis = J; break;
            case 'E': axis = E; break;
            case 'P': axis = P; break;
            default:
                if (*c >= 'A' && *c <= 'Z')
                  // Unknown axis, but we still want to remember that such a axis was seen.
                  axis = UNKNOWN_AXIS;
                break;
            }
            if (axis != NUM_AXES_WITH_UNKNOWN) {
                // Try to parse the numeric value.
                double v;
                auto [pend, ec] = fast_float::from_chars(++ c, end, v);
                if (pend != c && is_end_of_word(*pend)) {
                    // The axis value has been parsed correctly.
                    if (axis != UNKNOWN_AXIS)
                      gline.m_axis[int(axis)] = v;
                    gline.m_mask |= 1 << int(axis);
                    c = pend;
                } else
                    // Skip the rest of the word.
                    c = skip_word(c);
            } else
                // Skip the rest of the word.
                c = skip_word(c);
        }
    }
    
    if (gline.has(E) && m_use_relative_e_distances)
        m_position[E] = 0;
 
    // Skip the rest of the line.
    for (; ! is_end_of_line(*c); ++ c);
 
    // Copy the raw string including the comment, without the trailing newlines.
    if (c > ptr) {
        PROFILE_BLOCK(copy_raw_string);
        gline.m_raw.assign(ptr, c);
    }
 
    // Skip the trailing newlines.
  if (*c == '\r')
    ++ c;
  if (*c == '\n')
    ++ c;
 
    if (m_verbose)
        std::cout << gline.m_raw << std::endl;
 
    return c;
}

References Slic3r::E, Slic3r::F, Slic3r::GCodeReader::GCodeLine::has(), Slic3r::I, Slic3r::is_decimal_separator_point(), is_end_of_gcode_line(), is_end_of_line(), is_end_of_word(), Slic3r::J, Slic3r::GCodeReader::GCodeLine::m_axis, Slic3r::GCodeReader::GCodeLine::m_mask, m_position, Slic3r::GCodeReader::GCodeLine::m_raw, m_use_relative_e_distances, m_verbose, Slic3r::NUM_AXES_WITH_UNKNOWN, Slic3r::P, skip_whitespaces(), skip_word(), Slic3r::UNKNOWN_AXIS, Slic3r::X, Slic3r::Y, and Slic3r::Z.

Referenced by parse_line().

Here is the call graph for this function:

Here is the caller graph for this function:

quit_parsing()

void Slic3r::GCodeReader::quit_parsing ( )

inline

{ m_parsing = false; }

References m_parsing.

Referenced by Slic3r::GCodeProcessor::apply_config_simplify3d(), Slic3r::GCodeProcessor::contains_reserved_tag(), Slic3r::GCodeProcessor::contains_reserved_tags(), and Slic3r::custom_gcode_motion_state_changes().

Here is the caller graph for this function:

reset()

void Slic3r::GCodeReader::reset ( )

inline

{ memset(m_position, 0, sizeof(m_position)); }

References m_position.

Referenced by GCodeReader().

Here is the caller graph for this function:

skip_whitespaces()

const char * Slic3r::GCodeReader::skip_whitespaces ( const char * c )

inlinestaticprivate

                                                        { 
        for (; is_whitespace(*c); ++ c)
            ; // silence -Wempty-body
        return c;
    }

References is_whitespace().

Referenced by axis_pos(), Slic3r::GCodeReader::GCodeLine::cmd(), Slic3r::GCodeReader::GCodeLine::cmd_is(), Slic3r::GCodeReader::GCodeLine::cmd_starts_with(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), parse_file_internal(), and parse_line_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_word()

const char * Slic3r::GCodeReader::skip_word ( const char * c )

inlinestaticprivate

                                                 { 
        for (; ! is_end_of_word(*c); ++ c)
            ; // silence -Wempty-body
        return c;
    }

References is_end_of_word().

Referenced by axis_pos(), Slic3r::GCodeReader::GCodeLine::cmd(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::GCodeReader::GCodeLine::has_value(), parse_file_internal(), and parse_line_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

update_coordinates()

void Slic3r::GCodeReader::update_coordinates ( GCodeLine & gline, std::pair< const char *, const char * > & command )

private

{
    PROFILE_FUNC();
    if (*command.first == 'G') {
        int cmd_len = int(command.second - command.first);
        //BBS: add support of G2 and G3
        if ((cmd_len == 2 && (command.first[1] == '0' || command.first[1] == '1' || command.first[1] == '2' || command.first[1] == '3')) ||
            (cmd_len == 3 &&  command.first[1] == '9' && command.first[2] == '2')) {
            for (size_t i = 0; i < NUM_AXES; ++ i)
                if (gline.has(Axis(i)))
                    m_position[i] = gline.value(Axis(i));
        }
    }
}

References Slic3r::GCodeReader::GCodeLine::has(), i(), m_position, Slic3r::NUM_AXES, and Slic3r::GCodeReader::GCodeLine::value().

Referenced by parse_line().

Here is the call graph for this function:

Here is the caller graph for this function:

x() [1/2]

float & Slic3r::GCodeReader::x ( )

inline

{ return m_position[X]; }

References m_position, and Slic3r::X.

Referenced by Slic3r::FanMover::_process_gcode_line(), Slic3r::GCodeReader::GCodeLine::dist_X(), Slic3r::GCodeReader::GCodeLine::dist_XY(), and Slic3r::GCodeReader::GCodeLine::new_X().

Here is the caller graph for this function:

x() [2/2]

float Slic3r::GCodeReader::x ( ) const

inline

{ return m_position[X]; }

References m_position, and Slic3r::X.

y() [1/2]

float & Slic3r::GCodeReader::y ( )

inline

{ return m_position[Y]; }

References m_position, and Slic3r::Y.

Referenced by Slic3r::FanMover::_process_gcode_line(), Slic3r::GCodeReader::GCodeLine::dist_XY(), Slic3r::GCodeReader::GCodeLine::dist_Y(), and Slic3r::GCodeReader::GCodeLine::new_Y().

Here is the caller graph for this function:

y() [2/2]

float Slic3r::GCodeReader::y ( ) const

inline

{ return m_position[Y]; }

References m_position, and Slic3r::Y.

z() [1/2]

float & Slic3r::GCodeReader::z ( )

inline

{ return m_position[Z]; }

References m_position, and Slic3r::Z.

Referenced by Slic3r::FanMover::_process_gcode_line(), Slic3r::GCodeReader::GCodeLine::dist_Z(), and Slic3r::GCodeReader::GCodeLine::new_Z().

Here is the caller graph for this function:

z() [2/2]

float Slic3r::GCodeReader::z ( ) const

inline

{ return m_position[Z]; }

References m_position, and Slic3r::Z.

Member Data Documentation

m_config

std::shared_ptr<const GCodeConfig> Slic3r::GCodeReader::m_config

private

Referenced by apply_config(), apply_config(), config(), and get_config().

m_parsing

bool Slic3r::GCodeReader::m_parsing { false }

private

{ false };

Referenced by parse_buffer(), parse_file_raw_internal(), and quit_parsing().

m_position

float Slic3r::GCodeReader::m_position[NUM_AXES]

private

Referenced by e(), e(), f(), f(), i(), i(), j(), j(), parse_line_internal(), reset(), update_coordinates(), x(), x(), y(), y(), z(), and z().

m_use_relative_e_distances

bool Slic3r::GCodeReader::m_use_relative_e_distances { default_config().use_relative_e_distances.value }

private

{ default_config().use_relative_e_distances.value };

Referenced by apply_config(), apply_config(), and parse_line_internal().

m_verbose

bool Slic3r::GCodeReader::m_verbose

private

Referenced by GCodeReader(), and parse_line_internal().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCodeReader.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/GCodeReader.cpp