Slic3r::GCodeReader Class Reference

#include <src/libslic3r/GCodeReader.hpp>

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)
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
Point	xy_scaled () const
char	extrusion_axis () 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)

Private Attributes
GCodeConfig	m_config
char	m_extrusion_axis
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), m_extrusion_axis('E') { this->reset(); }

References reset().

Here is the call graph for this function:

Member Function Documentation

apply_config() [1/2]

void Slic3r::GCodeReader::apply_config

(

const DynamicPrintConfig &

config

)

{
    m_config.apply(config, true);
    m_extrusion_axis = get_extrusion_axis_char(m_config);
}

References Slic3r::get_extrusion_axis_char(), m_config, and m_extrusion_axis.

Here is the call graph for this function:

apply_config() [2/2]

void Slic3r::GCodeReader::apply_config

(

const GCodeConfig &

config

)

{
    m_config = config;
    m_extrusion_axis = get_extrusion_axis_char(m_config);
}

References Slic3r::get_extrusion_axis_char(), m_config, and m_extrusion_axis.

Referenced by Slic3r::SpiralVase::SpiralVase(), Slic3r::GCodeProcessor::apply_config(), and Slic3r::GCodeProcessor::apply_config().

Here is the call graph for this function:

Here is the caller 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::has(), Slic3r::GCodeReader::GCodeLine::has_value(), and Slic3r::GCodeReader::GCodeLine::has_value().

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::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.

extrusion_axis()

char Slic3r::GCodeReader::extrusion_axis ( ) const

inline

{ return m_extrusion_axis; }

References m_extrusion_axis.

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

Here is the caller graph for this function:

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.

is_end_of_gcode_line()

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

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

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

static 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:

parse_buffer() [1/2]

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

inline

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

References 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(), parse_buffer(), Slic3r::GCodeProcessor::process_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
	)

{
    return this->parse_file_internal(file, callback, [](size_t){});
}

References parse_file_internal().

Referenced by Slic3r::GCodeProcessor::process_file().

Here is the call graph for this function:

Here is the caller 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();
    return this->parse_file_internal(file, callback, [&lines_ends](size_t file_pos){ lines_ends.emplace_back(file_pos); });
}

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();
            this->parse_line(begin, end, gline, parse_line_callback);
        }, 
        line_end_callback);
}

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

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

Referenced by Slic3r::GCodeProcessor::apply_config_kissslicer(), Slic3r::GCodeProcessor::apply_config_simplify3d(), and Slic3r::GCodeProcessor::process_file().

Here is the call graph for this function:

Here is the caller 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 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 cmd, parse_line_internal(), and update_coordinates().

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

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

{
    assert(is_decimal_separator_point());
    
    // command and args
    const char *c = ptr;
    {
        // 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;
            default:
                if (*c == m_extrusion_axis) {
                    if (m_extrusion_axis != 0)
                        axis = E;
                } else 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;
                c = skip_whitespaces(++ c);
                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)] = float(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_config.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)
        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, fast_float::from_chars(), Slic3r::GCodeReader::GCodeLine::has(), Slic3r::is_decimal_separator_point(), is_end_of_gcode_line(), is_end_of_line(), is_end_of_word(), Slic3r::GCodeReader::GCodeLine::m_axis, m_config, m_extrusion_axis, Slic3r::GCodeReader::GCodeLine::m_mask, m_position, Slic3r::GCodeReader::GCodeLine::m_raw, m_verbose, Slic3r::NUM_AXES_WITH_UNKNOWN, 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_kissslicer(), Slic3r::GCodeProcessor::apply_config_simplify3d(), and Slic3r::GCodeProcessor::process_file().

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(), Slic3r::GCodeProcessor::apply_config_kissslicer(), and Slic3r::GCodeProcessor::process_file().

Here is the caller graph for this function:

skip_whitespaces()

static 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(), and parse_line_internal().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_word()

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

{
    if (*command.first == 'G') {
        int cmd_len = int(command.second - command.first);
        if ((cmd_len == 2 && (command.first[1] == '0' || command.first[1] == '1')) ||
            (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(), 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::GCodeReader::GCodeLine::dist_X(), Slic3r::GCodeReader::GCodeLine::dist_XY(), Slic3r::GCodeReader::GCodeLine::new_X(), and xy_scaled().

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.

xy_scaled()

Point Slic3r::GCodeReader::xy_scaled ( ) const

inline

{ return Point::new_scale(this->x(), this->y()); }

References x(), and y().

Here is the call graph for this function:

y() [1/2]

float & Slic3r::GCodeReader::y ( )

inline

{ return m_position[Y]; }

References m_position, and Slic3r::Y.

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

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

GCodeConfig Slic3r::GCodeReader::m_config

private

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

m_extrusion_axis

char Slic3r::GCodeReader::m_extrusion_axis

private

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

m_parsing

bool Slic3r::GCodeReader::m_parsing { false }

private

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(), parse_line_internal(), reset(), update_coordinates(), x(), x(), y(), y(), z(), and z().

m_verbose

bool Slic3r::GCodeReader::m_verbose

private

Referenced by parse_line_internal().

---

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

• src/libslic3r/GCodeReader.hpp
• src/libslic3r/GCodeReader.cpp