GCodeParser Class Reference

#include <parser.h>

Collaboration diagram for GCodeParser:

Public Member Functions
void	unknown_command_error ()

Static Public Member Functions
static void	reset ()
static FORCE_INLINE bool	valid_signless (const char *const p)
static FORCE_INLINE bool	valid_float (const char *const p)
static bool	seen (const char c)
static bool	seen_any ()
static bool	seen (const char *const str)
static bool	seen_axis ()
static void	parse (char *p)
static FORCE_INLINE bool	has_value ()
static bool	seenval (const char c)
static float	value_float ()
static int32_t	value_long ()
static uint32_t	value_ulong ()
static millis_t	value_millis ()
static millis_t	value_millis_from_seconds ()
static int16_t	value_int ()
static uint16_t	value_ushort ()
static uint8_t	value_byte ()
static bool	value_bool ()
static float	mm_to_linear_unit (const float mm)
static float	mm_to_volumetric_unit (const float mm)
static float	linear_value_to_mm (const float v)
static float	axis_value_to_mm (const AxisEnum, const float v)
static float	per_axis_value (const AxisEnum, const float v)
static float	value_linear_units ()
static float	value_axis_units (const AxisEnum axis)
static float	value_per_axis_units (const AxisEnum axis)
static float	value_celsius ()
static float	value_celsius_diff ()
static feedRate_t	value_feedrate ()
static float	floatval (const char c, const float dval=0.0)
static bool	boolval (const char c, const bool dval=false)
static uint8_t	byteval (const char c, const uint8_t dval=0)
static int16_t	intval (const char c, const int16_t dval=0)
static uint16_t	ushortval (const char c, const uint16_t dval=0)
static int32_t	longval (const char c, const int32_t dval=0)
static uint32_t	ulongval (const char c, const uint32_t dval=0)
static float	linearval (const char c, const float dval=0)
static float	celsiusval (const char c, const float dval=0)

Static Public Attributes
static bool	volumetric_enabled
static char *	command_ptr
static char *	string_arg
static char	command_letter
static int	codenum
static uint8_t	subcode

Detailed Description

Marlin 3D Printer Firmware Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

Based on Sprinter and grbl. Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/. parser.h - Parser for a GCode line, providing a parameter interface. Codes like M149 control the way the GCode parser behaves, so settings for these codes are located in this class. GCode parser

• Parse a single gcode line for its letter, code, subcode, and parameters
• FASTER_GCODE_PARSER:
  • Flags existing params (1 bit each)
  • Stores value offsets (1 byte each)
• Provide accessors for parameters:
  • Parameter exists
  • Parameter has value
  • Parameter value in different units and types

Member Function Documentation

reset()

void GCodeParser::reset ( )

static

Clear all code-seen (and value pointers)

Since each param is set/cleared on seen codes, this may be optimized by commenting out ZERO(param)

                        {
  string_arg = nullptr;                 // No whole line argument
  command_letter = '?';                 // No command letter
  codenum = 0;                          // No command code
  #if USE_GCODE_SUBCODES
    subcode = 0;                        // No command sub-code
  #endif
  #if ENABLED(FASTER_GCODE_PARSER)
    codebits = 0;                       // No codes yet
    //ZERO(param);                      // No parameters (should be safe to comment out this line)
  #endif
}

Here is the caller graph for this function:

valid_signless()

static FORCE_INLINE bool GCodeParser::valid_signless ( const char *const  p )

static

                                                                {
    return NUMERIC(p[0]) || (p[0] == '.' && NUMERIC(p[1])); // .?[0-9]
  }

Here is the caller graph for this function:

valid_float()

static FORCE_INLINE bool GCodeParser::valid_float ( const char *const  p )

static

                                                             {
    return valid_signless(p) || ((p[0] == '-' || p[0] == '+') && valid_signless(&p[1])); // [-+]?.?[0-9]
  }

Here is the call graph for this function:

Here is the caller graph for this function:

seen() [1/2]

static bool GCodeParser::seen ( const char  c )

static

                                          {
      char *p = strchr(command_args, c);
      const bool b = !!p;
      if (b) value_ptr = valid_float(&p[1]) ? &p[1] : nullptr;
      return b;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

seen_any()

static bool GCodeParser::seen_any ( )

static

{ return *command_args == '\0'; }

seen() [2/2]

static bool GCodeParser::seen ( const char *const  str )

static

                                                    {
      for (uint8_t i = 0; const char c = str[i]; i++)
        if (SEEN_TEST(c)) return true;
      return false;
    }

seen_axis()

static bool GCodeParser::seen_axis ( )

static

                                 {
    return SEEN_TEST('X') || SEEN_TEST('Y') || SEEN_TEST('Z') || SEEN_TEST('E');
  }

parse()

void GCodeParser::parse ( char *  p )

static

Find all parameters, set flags and pointers for fast parsing

Most codes ignore 'string_arg', but those that want a string will get the right pointer. The following loop assigns the first "parameter" having no numeric value to 'string_arg'. This allows M0/M1 with expire time to work: "M0 S5 You Win!" For 'M118' you must use 'E1' and 'A1' rather than just 'E' or 'A'

                               {
 
  reset(); // No codes to report
 
  // Skip spaces
  while (*p == ' ') ++p;
 
  // Skip N[-0-9] if included in the command line
  if (*p == 'N' && NUMERIC_SIGNED(p[1])) {
    #if ENABLED(FASTER_GCODE_PARSER)
      //set('N', p + 1);     // (optional) Set the 'N' parameter value
    #endif
    p += 2;                  // skip N[-0-9]
    while (NUMERIC(*p)) ++p; // skip [0-9]*
    while (*p == ' ')   ++p; // skip [ ]*
  }
 
  // *p now points to the current command, which should be G, M, or T
  command_ptr = p;
 
  // Get the command letter, which must be G, M, or T
  const char letter = *p++;
 
  // Nullify asterisk and trailing whitespace
  char *starpos = strchr(p, '*');
  if (starpos) {
    --starpos;                          // *
    while (*starpos == ' ') --starpos;  // spaces...
    starpos[1] = '\0';
  }
 
  #if ENABLED(GCODE_MOTION_MODES)
    #if ENABLED(ARC_SUPPORT)
      #define GTOP 3
    #else
      #define GTOP 1
    #endif
  #endif
 
  // Bail if the letter is not G, M, or T
  // (or a valid parameter for the current motion mode)
  switch (letter) {
 
    case 'G': case 'M': case 'T':
 
      // Skip spaces to get the numeric part
      while (*p == ' ') p++;
 
      #if ENABLED(PRUSA_MMU2)
        if (letter == 'T') {
          // check for special MMU2 T?/Tx/Tc commands
          if (*p == '?' || *p == 'x' || *p == 'c') {
            command_letter = letter;
            string_arg = p;
            return;
          }
        }
      #endif
 
      // Bail if there's no command code number
      if (!NUMERIC(*p)) return;
 
      // Save the command letter at this point
      // A '?' signifies an unknown command
      command_letter = letter;
 
      // Get the code number - integer digits only
      codenum = 0;
      do { codenum *= 10, codenum += *p++ - '0'; } while (NUMERIC(*p));
 
      // Allow for decimal point in command
      #if USE_GCODE_SUBCODES
      if (*p == '.') {
        p++;
        while (NUMERIC(*p))
        subcode *= 10, subcode += *p++ - '0';
      }
      #endif
 
      // Skip all spaces to get to the first argument, or nul
      while (*p == ' ') p++;
 
      #if ENABLED(GCODE_MOTION_MODES)
        if (letter == 'G' && (codenum <= GTOP || codenum == 5
                                #if ENABLED(G38_PROBE_TARGET)
                                  || codenum == 38
                                #endif
                             )
        ) {
          motion_mode_codenum = codenum;
          #if USE_GCODE_SUBCODES
            motion_mode_subcode = subcode;
          #endif
        }
      #endif
 
      break;
 
    #if ENABLED(GCODE_MOTION_MODES)
      #if ENABLED(ARC_SUPPORT)
        case 'I': case 'J': case 'R':
          if (motion_mode_codenum != 2 && motion_mode_codenum != 3) return;
      #endif
      case 'P': case 'Q':
        if (motion_mode_codenum != 5) return;
      case 'X': case 'Y': case 'Z': case 'E': case 'F':
        if (motion_mode_codenum < 0) return;
        command_letter = 'G';
        codenum = motion_mode_codenum;
        #if USE_GCODE_SUBCODES
          subcode = motion_mode_subcode;
        #endif
        p--; // Back up one character to use the current parameter
      break;
    #endif // GCODE_MOTION_MODES
 
    default: return;
  }
 
  // The command parameters (if any) start here, for sure!
 
  #if DISABLED(FASTER_GCODE_PARSER)
    command_args = p; // Scan for parameters in seen()
  #endif
 
  // Only use string_arg for these M codes
  if (letter == 'M') switch (codenum) {
    #if ENABLED(GCODE_MACROS)
      case 810 ... 819:
    #endif
    #if ENABLED(EXPECTED_PRINTER_CHECK)
      case 16:
    #endif
    case 23: case 28: case 30: case 117: case 118: case 928: string_arg = p; return;
    default: break;
  }
 
  #if ENABLED(DEBUG_GCODE_PARSER)
    const bool debug = codenum == 800;
  #endif
 
  /**
   * Find all parameters, set flags and pointers for fast parsing
   *
   * Most codes ignore 'string_arg', but those that want a string will get the right pointer.
   * The following loop assigns the first "parameter" having no numeric value to 'string_arg'.
   * This allows M0/M1 with expire time to work: "M0 S5 You Win!"
   * For 'M118' you must use 'E1' and 'A1' rather than just 'E' or 'A'
   */
  string_arg = nullptr;
  while (const char code = *p++) {              // Get the next parameter. A NUL ends the loop
 
    // Special handling for M32 [P] !/path/to/file.g#
    // The path must be the last parameter
    if (code == '!' && letter == 'M' && codenum == 32) {
      string_arg = p;                           // Name starts after '!'
      char * const lb = strchr(p, '#');         // Already seen '#' as SD char (to pause buffering)
      if (lb) *lb = '\0';                       // Safe to mark the end of the filename
      return;
    }
 
    // Arguments MUST be uppercase for fast GCode parsing
    #if ENABLED(FASTER_GCODE_PARSER)
      #define PARAM_TEST WITHIN(code, 'A', 'Z')
    #else
      #define PARAM_TEST true
    #endif
 
    if (PARAM_TEST) {
 
      while (*p == ' ') p++;                    // Skip spaces between parameters & values
 
      const bool has_num = valid_float(p);
 
      #if ENABLED(DEBUG_GCODE_PARSER)
        if (debug) {
          SERIAL_ECHOPAIR("Got letter ", code, " at index ", (int)(p - command_ptr - 1));
          if (has_num) SERIAL_ECHOPGM(" (has_num)");
        }
      #endif
 
      if (!has_num && !string_arg) {            // No value? First time, keep as string_arg
        string_arg = p - 1;
        #if ENABLED(DEBUG_GCODE_PARSER)
          if (debug) SERIAL_ECHOPAIR(" string_arg: ", hex_address((void*)string_arg)); // DEBUG
        #endif
      }
 
      #if ENABLED(DEBUG_GCODE_PARSER)
        if (debug) SERIAL_EOL();
      #endif
 
      #if ENABLED(FASTER_GCODE_PARSER)
        set(code, has_num ? p : nullptr);       // Set parameter exists and pointer (nullptr for no number)
      #endif
    }
    else if (!string_arg) {                     // Not A-Z? First time, keep as the string_arg
      string_arg = p - 1;
      #if ENABLED(DEBUG_GCODE_PARSER)
        if (debug) SERIAL_ECHOPAIR(" string_arg: ", hex_address((void*)string_arg)); // DEBUG
      #endif
    }
 
    if (!WITHIN(*p, 'A', 'Z')) {                // Another parameter right away?
      while (*p && DECIMAL_SIGNED(*p)) p++;     // Skip over the value section of a parameter
      while (*p == ' ') p++;                    // Skip over all spaces
    }
  }
}

Here is the call graph for this function:

has_value()

static FORCE_INLINE bool GCodeParser::has_value ( )

static

{ return value_ptr != nullptr; }

Here is the caller graph for this function:

seenval()

static bool GCodeParser::seenval ( const char  c )

static

{ return seen(c) && has_value(); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_float()

static float GCodeParser::value_float ( )

static

                                    {
    if (value_ptr) {
      char *e = value_ptr;
      for (;;) {
        const char c = *e;
        if (c == '\0' || c == ' ') break;
        if (c == 'E' || c == 'e') {
          *e = '\0';
          const float ret = strtof(value_ptr, nullptr);
          *e = c;
          return ret;
        }
        ++e;
      }
      return strtof(value_ptr, nullptr);
    }
    return 0;
  }

Here is the caller graph for this function:

value_long()

static int32_t GCodeParser::value_long ( )

static

{ return value_ptr ? strtol(value_ptr, nullptr, 10) : 0L; }

Here is the caller graph for this function:

value_ulong()

static uint32_t GCodeParser::value_ulong ( )

static

{ return value_ptr ? strtoul(value_ptr, nullptr, 10) : 0UL; }

Here is the caller graph for this function:

value_millis()

static millis_t GCodeParser::value_millis ( )

static

{ return value_ulong(); }

Here is the call graph for this function:

value_millis_from_seconds()

static millis_t GCodeParser::value_millis_from_seconds ( )

static

{ return (millis_t)(value_float() * 1000); }

Here is the call graph for this function:

value_int()

static int16_t GCodeParser::value_int ( )

static

{ return (int16_t)value_long(); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_ushort()

static uint16_t GCodeParser::value_ushort ( )

static

{ return (uint16_t)value_long(); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_byte()

static uint8_t GCodeParser::value_byte ( )

static

{ return (uint8_t)constrain(value_long(), 0, 255); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_bool()

static bool GCodeParser::value_bool ( )

static

{ return !has_value() || !!value_byte(); }

Here is the call graph for this function:

Here is the caller graph for this function:

mm_to_linear_unit()

static float GCodeParser::mm_to_linear_unit ( const float  mm )

static

{ return mm; }

mm_to_volumetric_unit()

static float GCodeParser::mm_to_volumetric_unit ( const float  mm )

static

{ return mm; }

linear_value_to_mm()

static float GCodeParser::linear_value_to_mm ( const float  v )

static

{ return v; }

Here is the caller graph for this function:

axis_value_to_mm()

static float GCodeParser::axis_value_to_mm ( const  AxisEnum, const float  v  )

static

{ return v; }

Here is the caller graph for this function:

per_axis_value()

static float GCodeParser::per_axis_value ( const  AxisEnum, const float  v  )

static

{ return v; }

Here is the caller graph for this function:

value_linear_units()

static float GCodeParser::value_linear_units ( )

static

{ return linear_value_to_mm(value_float()); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_axis_units()

static float GCodeParser::value_axis_units ( const AxisEnum  axis )

static

{ return axis_value_to_mm(axis, value_float()); }

Here is the call graph for this function:

value_per_axis_units()

static float GCodeParser::value_per_axis_units ( const AxisEnum  axis )

static

{ return per_axis_value(axis, value_float()); }

Here is the call graph for this function:

value_celsius()

static float GCodeParser::value_celsius ( )

static

{ return value_float(); }

Here is the call graph for this function:

Here is the caller graph for this function:

value_celsius_diff()

static float GCodeParser::value_celsius_diff ( )

static

{ return value_float(); }

Here is the call graph for this function:

value_feedrate()

static feedRate_t GCodeParser::value_feedrate ( )

static

{ return MMM_TO_MMS(value_linear_units()); }

Here is the call graph for this function:

unknown_command_error()

void GCodeParser::unknown_command_error

(

)

                                        {
  SERIAL_ECHO_START();
  SERIAL_ECHOLNPAIR(MSG_UNKNOWN_COMMAND, command_ptr, "\"");
}

floatval()

static float GCodeParser::floatval ( const char  c, const float  dval = 0.0  )

static

{ return seenval(c) ? value_float()        : dval; }

Here is the call graph for this function:

boolval()

static bool GCodeParser::boolval ( const char  c, const bool  dval = false  )

static

{ return seenval(c) ? value_bool()         : (seen(c) ? true : dval); }

Here is the call graph for this function:

byteval()

static uint8_t GCodeParser::byteval ( const char  c, const uint8_t  dval = 0  )

static

{ return seenval(c) ? value_byte()         : dval; }

Here is the call graph for this function:

intval()

static int16_t GCodeParser::intval ( const char  c, const int16_t  dval = 0  )

static

{ return seenval(c) ? value_int()          : dval; }

Here is the call graph for this function:

ushortval()

static uint16_t GCodeParser::ushortval ( const char  c, const uint16_t  dval = 0  )

static

{ return seenval(c) ? value_ushort()       : dval; }

Here is the call graph for this function:

longval()

static int32_t GCodeParser::longval ( const char  c, const int32_t  dval = 0  )

static

{ return seenval(c) ? value_long()         : dval; }

Here is the call graph for this function:

ulongval()

static uint32_t GCodeParser::ulongval ( const char  c, const uint32_t  dval = 0  )

static

{ return seenval(c) ? value_ulong()        : dval; }

Here is the call graph for this function:

linearval()

static float GCodeParser::linearval ( const char  c, const float  dval = 0  )

static

{ return seenval(c) ? value_linear_units() : dval; }

Here is the call graph for this function:

celsiusval()

static float GCodeParser::celsiusval ( const char  c, const float  dval = 0  )

static

{ return seenval(c) ? value_celsius()      : dval; }

Here is the call graph for this function:

Member Data Documentation

volumetric_enabled

bool GCodeParser::volumetric_enabled

static

Marlin 3D Printer Firmware Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

Based on Sprinter and grbl. Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/. parser.cpp - Parser for a GCode line, providing a parameter interface.

command_ptr

char * GCodeParser::command_ptr

static

string_arg

char * GCodeParser::string_arg

static

command_letter

char GCodeParser::command_letter

static

codenum

int GCodeParser::codenum

static

subcode

uint8_t GCodeParser::subcode

static