diff --git a/Marlin/Conditionals_post.h b/Marlin/Conditionals_post.h
index c40289ea5..a4ae28ff3 100644
--- a/Marlin/Conditionals_post.h
+++ b/Marlin/Conditionals_post.h
@@ -838,4 +838,7 @@
   // Shorthand
   #define GRID_MAX_POINTS ((GRID_MAX_POINTS_X) * (GRID_MAX_POINTS_Y))
 
+  // Add commands that need sub-codes to this list
+  #define USE_GCODE_SUBCODES ENABLED(G38_PROBE_TARGET)
+
 #endif // CONDITIONALS_POST_H
diff --git a/Marlin/G26_Mesh_Validation_Tool.cpp b/Marlin/G26_Mesh_Validation_Tool.cpp
index 0bae98391..a17adda10 100644
--- a/Marlin/G26_Mesh_Validation_Tool.cpp
+++ b/Marlin/G26_Mesh_Validation_Tool.cpp
@@ -34,6 +34,7 @@
   #include "stepper.h"
   #include "temperature.h"
   #include "ultralcd.h"
+  #include "gcode.h"
 
   #define EXTRUSION_MULTIPLIER 1.0
   #define RETRACTION_MULTIPLIER 1.0
@@ -130,11 +131,7 @@
   void set_destination_to_current();
   void set_current_to_destination();
   void prepare_move_to_destination();
-  float code_value_float();
-  float code_value_linear_units();
-  float code_value_axis_units(const AxisEnum axis);
-  bool code_value_bool();
-  bool code_has_value();
+  void lcd_setstatuspgm(const char* const message, const uint8_t level);
   void sync_plan_position_e();
   void chirp_at_user();
 
@@ -625,29 +622,29 @@
     g26_hotend_temp           = HOTEND_TEMP;
     g26_prime_flag            = 0;
 
-    g26_ooze_amount           = code_seen('O') && code_has_value() ? code_value_linear_units() : OOZE_AMOUNT;
-    g26_keep_heaters_on       = code_seen('K') && code_value_bool();
-    g26_continue_with_closest = code_seen('C') && code_value_bool();
+    g26_ooze_amount           = parser.seen('O') && parser.has_value() ? parser.value_linear_units() : OOZE_AMOUNT;
+    g26_keep_heaters_on       = parser.seen('K') && parser.value_bool();
+    g26_continue_with_closest = parser.seen('C') && parser.value_bool();
 
-    if (code_seen('B')) {
-      g26_bed_temp = code_value_temp_abs();
+    if (parser.seen('B')) {
+      g26_bed_temp = parser.value_celsius();
       if (!WITHIN(g26_bed_temp, 15, 140)) {
         SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible.");
         return UBL_ERR;
       }
     }
 
-    if (code_seen('L')) {
-      g26_layer_height = code_value_linear_units();
+    if (parser.seen('L')) {
+      g26_layer_height = parser.value_linear_units();
       if (!WITHIN(g26_layer_height, 0.0, 2.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible.");
         return UBL_ERR;
       }
     }
 
-    if (code_seen('Q')) {
-      if (code_has_value()) {
-        g26_retraction_multiplier = code_value_float();
+    if (parser.seen('Q')) {
+      if (parser.has_value()) {
+        g26_retraction_multiplier = parser.value_float();
         if (!WITHIN(g26_retraction_multiplier, 0.05, 15.0)) {
           SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible.");
           return UBL_ERR;
@@ -659,20 +656,20 @@
       }
     }
 
-    if (code_seen('S')) {
-      g26_nozzle = code_value_float();
+    if (parser.seen('S')) {
+      g26_nozzle = parser.value_float();
       if (!WITHIN(g26_nozzle, 0.1, 1.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
         return UBL_ERR;
       }
     }
 
-    if (code_seen('P')) {
-      if (!code_has_value())
+    if (parser.seen('P')) {
+      if (!parser.has_value())
         g26_prime_flag = -1;
       else {
         g26_prime_flag++;
-        g26_prime_length = code_value_linear_units();
+        g26_prime_length = parser.value_linear_units();
         if (!WITHIN(g26_prime_length, 0.0, 25.0)) {
           SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible.");
           return UBL_ERR;
@@ -680,8 +677,8 @@
       }
     }
 
-    if (code_seen('F')) {
-      g26_filament_diameter = code_value_linear_units();
+    if (parser.seen('F')) {
+      g26_filament_diameter = parser.value_linear_units();
       if (!WITHIN(g26_filament_diameter, 1.0, 4.0)) {
         SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible.");
         return UBL_ERR;
@@ -693,27 +690,28 @@
 
     g26_extrusion_multiplier *= g26_filament_diameter * sq(g26_nozzle) / sq(0.3); // Scale up by nozzle size
 
-    if (code_seen('H')) {
-      g26_hotend_temp = code_value_temp_abs();
+    if (parser.seen('H')) {
+      g26_hotend_temp = parser.value_celsius();
       if (!WITHIN(g26_hotend_temp, 165, 280)) {
         SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible.");
         return UBL_ERR;
       }
     }
 
-    if (code_seen('U')) {
+    if (parser.seen('U')) {
       randomSeed(millis());
-      random_deviation = code_has_value() ? code_value_float() : 50.0;
+      // This setting will persist for the next G26
+      random_deviation = parser.has_value() ? parser.value_float() : 50.0;
     }
 
-    g26_repeats = code_seen('R') ? (code_has_value() ? code_value_int() : GRID_MAX_POINTS+1) : GRID_MAX_POINTS+1;
+    g26_repeats = parser.seen('R') ? (parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1) : GRID_MAX_POINTS + 1;
     if (g26_repeats < 1) {
       SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1.");
       return UBL_ERR;
     }
 
-    g26_x_pos = code_seen('X') ? code_value_linear_units() : current_position[X_AXIS];
-    g26_y_pos = code_seen('Y') ? code_value_linear_units() : current_position[Y_AXIS];
+    g26_x_pos = parser.seen('X') ? parser.value_linear_units() : current_position[X_AXIS];
+    g26_y_pos = parser.seen('Y') ? parser.value_linear_units() : current_position[Y_AXIS];
     if (!position_is_reachable_xy(g26_x_pos, g26_y_pos)) {
       SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds.");
       return UBL_ERR;
@@ -722,7 +720,7 @@
     /**
      * Wait until all parameters are verified before altering the state!
      */
-    state.active = !code_seen('D');
+    state.active = !parser.seen('D');
 
     return UBL_OK;
   }
diff --git a/Marlin/M100_Free_Mem_Chk.cpp b/Marlin/M100_Free_Mem_Chk.cpp
index 6b5edebff..cfc001de2 100644
--- a/Marlin/M100_Free_Mem_Chk.cpp
+++ b/Marlin/M100_Free_Mem_Chk.cpp
@@ -61,6 +61,7 @@ extern size_t  __heap_start, __heap_end, __flp;
 extern char __bss_end;
 
 #include "Marlin.h"
+#include "gcode.h"
 #include "hex_print_routines.h"
 
 //
@@ -188,7 +189,7 @@ void free_memory_pool_report(char * const ptr, const int16_t size) {
    *  This is useful to check the correctness of the M100 D and the M100 F commands.
    */
   void corrupt_free_memory(char *ptr, const uint16_t size) {
-    if (code_seen('C')) {
+    if (parser.seen('C')) {
       ptr += 8;
       const uint16_t near_top = top_of_stack() - ptr - 250, // -250 to avoid interrupt activity that's altered the stack.
                      j = near_top / (size + 1);
@@ -247,23 +248,23 @@ void gcode_M100() {
 
   // Always init on the first invocation of M100
   static bool m100_not_initialized = true;
-  if (m100_not_initialized || code_seen('I')) {
+  if (m100_not_initialized || parser.seen('I')) {
     m100_not_initialized = false;
     init_free_memory(ptr, sp - ptr);
   }
 
   #if ENABLED(M100_FREE_MEMORY_DUMPER)
-    if (code_seen('D'))
+    if (parser.seen('D'))
       return dump_free_memory(ptr, sp);
   #endif
 
-  if (code_seen('F'))
+  if (parser.seen('F'))
     return free_memory_pool_report(ptr, sp - ptr);
 
   #if ENABLED(M100_FREE_MEMORY_CORRUPTOR)
 
-    if (code_seen('C'))
-      return corrupt_free_memory(ptr, code_value_int());
+    if (parser.seen('C'))
+      return corrupt_free_memory(ptr, parser.value_int());
 
   #endif
 }
diff --git a/Marlin/Marlin.h b/Marlin/Marlin.h
index 37f539320..aecd89b32 100644
--- a/Marlin/Marlin.h
+++ b/Marlin/Marlin.h
@@ -287,22 +287,6 @@ extern float soft_endstop_min[XYZ], soft_endstop_max[XYZ];
   void update_software_endstops(const AxisEnum axis);
 #endif
 
-// GCode support for external objects
-bool code_seen(char);
-int code_value_int();
-int16_t code_value_temp_abs();
-int16_t code_value_temp_diff();
-
-#if ENABLED(INCH_MODE_SUPPORT)
-  float code_value_linear_units();
-  float code_value_axis_units(const AxisEnum axis);
-  float code_value_per_axis_unit(const AxisEnum axis);
-#else
-  #define code_value_linear_units() code_value_float()
-  #define code_value_axis_units(A) code_value_float()
-  #define code_value_per_axis_unit(A) code_value_float()
-#endif
-
 #if IS_KINEMATIC
   extern float delta[ABC];
   void inverse_kinematics(const float logical[XYZ]);
@@ -490,4 +474,4 @@ FORCE_INLINE bool position_is_reachable_xy(const float &lx, const float &ly) {
   return position_is_reachable_raw_xy(RAW_X_POSITION(lx), RAW_Y_POSITION(ly));
 }
 
-#endif //MARLIN_H
+#endif // MARLIN_H
diff --git a/Marlin/Marlin_main.cpp b/Marlin/Marlin_main.cpp
index 2e5d08e76..6547cc152 100644
--- a/Marlin/Marlin_main.cpp
+++ b/Marlin/Marlin_main.cpp
@@ -242,6 +242,7 @@
 #include "nozzle.h"
 #include "duration_t.h"
 #include "types.h"
+#include "gcode.h"
 
 #if HAS_ABL
   #include "vector_3.h"
@@ -373,14 +374,6 @@ static uint8_t cmd_queue_index_r = 0, // Ring buffer read position
 static char command_queue[BUFSIZE][MAX_CMD_SIZE];
 #endif
 
-/**
- * Current GCode Command
- * When a GCode handler is running, these will be set
- */
-static char *current_command,      // The command currently being executed
-            *current_command_args, // The address where arguments begin
-            *seen_pointer;         // Set by code_seen(), used by the code_value functions
-
 /**
  * Next Injected Command pointer. NULL if no commands are being injected.
  * Used by Marlin internally to ensure that commands initiated from within
@@ -388,10 +381,6 @@ static char *current_command,      // The command currently being executed
  */
 static const char *injected_commands_P = NULL;
 
-#if ENABLED(INCH_MODE_SUPPORT)
-  float linear_unit_factor = 1.0, volumetric_unit_factor = 1.0;
-#endif
-
 #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
   TempUnit input_temp_units = TEMPUNIT_C;
 #endif
@@ -408,7 +397,8 @@ float constexpr homing_feedrate_mm_s[] = {
   #endif
   MMM_TO_MMS(HOMING_FEEDRATE_Z), 0
 };
-float feedrate_mm_s = MMM_TO_MMS(1500.0), saved_feedrate_mm_s;
+float feedrate_mm_s = MMM_TO_MMS(1500.0);
+static float saved_feedrate_mm_s;
 int feedrate_percentage = 100, saved_feedrate_percentage,
     flow_percentage[EXTRUDERS] = ARRAY_BY_EXTRUDERS1(100);
 
@@ -1056,8 +1046,8 @@ inline void get_serial_commands() {
       char* command = serial_line_buffer;
 
       while (*command == ' ') command++; // skip any leading spaces
-      char* npos = (*command == 'N') ? command : NULL; // Require the N parameter to start the line
-      char* apos = strchr(command, '*');
+      char *npos = (*command == 'N') ? command : NULL, // Require the N parameter to start the line
+           *apos = strchr(command, '*');
 
       if (npos) {
 
@@ -1249,125 +1239,21 @@ void get_available_commands() {
   #endif
 }
 
-inline bool code_has_value() {
-  int i = 1;
-  char c = seen_pointer[i];
-  while (c == ' ') c = seen_pointer[++i];
-  if (c == '-' || c == '+') c = seen_pointer[++i];
-  if (c == '.') c = seen_pointer[++i];
-  return NUMERIC(c);
-}
-
-inline float code_value_float() {
-  char* e = strchr(seen_pointer, 'E');
-  if (!e) return strtod(seen_pointer + 1, NULL);
-  *e = 0;
-  float ret = strtod(seen_pointer + 1, NULL);
-  *e = 'E';
-  return ret;
-}
-
-inline unsigned long code_value_ulong() { return strtoul(seen_pointer + 1, NULL, 10); }
-
-inline long code_value_long() { return strtol(seen_pointer + 1, NULL, 10); }
-
-inline int code_value_int() { return (int)strtol(seen_pointer + 1, NULL, 10); }
-
-inline uint16_t code_value_ushort() { return (uint16_t)strtoul(seen_pointer + 1, NULL, 10); }
-
-inline uint8_t code_value_byte() { return (uint8_t)(constrain(strtol(seen_pointer + 1, NULL, 10), 0, 255)); }
-
-inline bool code_value_bool() { return !code_has_value() || code_value_byte() > 0; }
-
-#if ENABLED(INCH_MODE_SUPPORT)
-  inline void set_input_linear_units(LinearUnit units) {
-    switch (units) {
-      case LINEARUNIT_INCH:
-        linear_unit_factor = 25.4;
-        break;
-      case LINEARUNIT_MM:
-      default:
-        linear_unit_factor = 1.0;
-        break;
-    }
-    volumetric_unit_factor = pow(linear_unit_factor, 3.0);
-  }
-
-  inline float axis_unit_factor(const AxisEnum axis) {
-    return (axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor);
-  }
-
-  inline float code_value_linear_units() { return code_value_float() * linear_unit_factor; }
-  inline float code_value_axis_units(const AxisEnum axis) { return code_value_float() * axis_unit_factor(axis); }
-  inline float code_value_per_axis_unit(const AxisEnum axis) { return code_value_float() / axis_unit_factor(axis); }
-#endif
-
-#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
-  inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
-
-  float to_temp_units(const float &c) {
-    switch (input_temp_units) {
-      case TEMPUNIT_F:
-        return c * 0.5555555556 + 32.0;
-      case TEMPUNIT_K:
-        return c + 273.15;
-      case TEMPUNIT_C:
-      default:
-        return c;
-    }
-  }
-
-  int16_t code_value_temp_abs() {
-    const float c = code_value_float();
-    switch (input_temp_units) {
-      case TEMPUNIT_F:
-        return (int16_t)((c - 32.0) * 0.5555555556);
-      case TEMPUNIT_K:
-        return (int16_t)(c - 273.15);
-      case TEMPUNIT_C:
-      default:
-        return (int16_t)(c);
-    }
-  }
-
-  int16_t code_value_temp_diff() {
-    switch (input_temp_units) {
-      case TEMPUNIT_F:
-        return code_value_float() * 0.5555555556;
-      case TEMPUNIT_C:
-      case TEMPUNIT_K:
-      default:
-        return code_value_float();
-    }
-  }
-#else
-  int16_t code_value_temp_abs() { return code_value_int(); }
-  int16_t code_value_temp_diff() { return code_value_int(); }
-#endif
-
-FORCE_INLINE millis_t code_value_millis() { return code_value_ulong(); }
-inline millis_t code_value_millis_from_seconds() { return code_value_float() * 1000; }
-
-bool code_seen(char code) {
-  seen_pointer = strchr(current_command_args, code);
-  return (seen_pointer != NULL); // Return TRUE if the code-letter was found
-}
-
 /**
  * Set target_extruder from the T parameter or the active_extruder
  *
  * Returns TRUE if the target is invalid
  */
 bool get_target_extruder_from_command(int code) {
-  if (code_seen('T')) {
-    if (code_value_byte() >= EXTRUDERS) {
+  if (parser.seen('T')) {
+    if (parser.value_byte() >= EXTRUDERS) {
       SERIAL_ECHO_START;
       SERIAL_CHAR('M');
       SERIAL_ECHO(code);
-      SERIAL_ECHOLNPAIR(" " MSG_INVALID_EXTRUDER " ", code_value_byte());
+      SERIAL_ECHOLNPAIR(" " MSG_INVALID_EXTRUDER " ", parser.value_byte());
       return true;
     }
-    target_extruder = code_value_byte();
+    target_extruder = parser.value_byte();
   }
   else
     target_extruder = active_extruder;
@@ -3141,9 +3027,9 @@ static void homeaxis(const AxisEnum axis) {
       const char* mixing_codes = "ABCDHI";
       byte mix_bits = 0;
       for (uint8_t i = 0; i < MIXING_STEPPERS; i++) {
-        if (code_seen(mixing_codes[i])) {
+        if (parser.seen(mixing_codes[i])) {
           SBI(mix_bits, i);
-          float v = code_value_float();
+          float v = parser.value_float();
           NOLESS(v, 0.0);
           mixing_factor[i] = RECIPROCAL(v);
         }
@@ -3175,14 +3061,14 @@ static void homeaxis(const AxisEnum axis) {
  */
 void gcode_get_destination() {
   LOOP_XYZE(i) {
-    if (code_seen(axis_codes[i]))
-      destination[i] = code_value_axis_units((AxisEnum)i) + (axis_relative_modes[i] || relative_mode ? current_position[i] : 0);
+    if (parser.seen(axis_codes[i]))
+      destination[i] = parser.value_axis_units((AxisEnum)i) + (axis_relative_modes[i] || relative_mode ? current_position[i] : 0);
     else
       destination[i] = current_position[i];
   }
 
-  if (code_seen('F') && code_value_linear_units() > 0.0)
-    feedrate_mm_s = MMM_TO_MMS(code_value_linear_units());
+  if (parser.seen('F') && parser.value_linear_units() > 0.0)
+    feedrate_mm_s = MMM_TO_MMS(parser.value_feedrate());
 
   #if ENABLED(PRINTCOUNTER)
     if (!DEBUGGING(DRYRUN))
@@ -3195,13 +3081,6 @@ void gcode_get_destination() {
   #endif
 }
 
-void unknown_command_error() {
-  SERIAL_ECHO_START;
-  SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, current_command);
-  SERIAL_CHAR('"');
-  SERIAL_EOL;
-}
-
 #if ENABLED(HOST_KEEPALIVE_FEATURE)
 
   /**
@@ -3253,7 +3132,7 @@ inline void gcode_G0_G1(
 
     #if ENABLED(FWRETRACT)
 
-      if (autoretract_enabled && !(code_seen('X') || code_seen('Y') || code_seen('Z')) && code_seen('E')) {
+      if (autoretract_enabled && !(parser.seen('X') || parser.seen('Y') || parser.seen('Z')) && parser.seen('E')) {
         const float echange = destination[E_AXIS] - current_position[E_AXIS];
         // Is this move an attempt to retract or recover?
         if ((echange < -MIN_RETRACT && !retracted[active_extruder]) || (echange > MIN_RETRACT && retracted[active_extruder])) {
@@ -3264,7 +3143,7 @@ inline void gcode_G0_G1(
         }
       }
 
-    #endif //FWRETRACT
+    #endif // FWRETRACT
 
     #if IS_SCARA
       fast_move ? prepare_uninterpolated_move_to_destination() : prepare_move_to_destination();
@@ -3313,8 +3192,8 @@ inline void gcode_G0_G1(
       #endif
 
       float arc_offset[2] = { 0.0, 0.0 };
-      if (code_seen('R')) {
-        const float r = code_value_linear_units(),
+      if (parser.seen('R')) {
+        const float r = parser.value_linear_units(),
                     x1 = current_position[X_AXIS], y1 = current_position[Y_AXIS],
                     x2 = destination[X_AXIS], y2 = destination[Y_AXIS];
         if (r && (x2 != x1 || y2 != y1)) {
@@ -3330,8 +3209,8 @@ inline void gcode_G0_G1(
         }
       }
       else {
-        if (code_seen('I')) arc_offset[X_AXIS] = code_value_linear_units();
-        if (code_seen('J')) arc_offset[Y_AXIS] = code_value_linear_units();
+        if (parser.seen('I')) arc_offset[X_AXIS] = parser.value_linear_units();
+        if (parser.seen('J')) arc_offset[Y_AXIS] = parser.value_linear_units();
       }
 
       if (arc_offset[0] || arc_offset[1]) {
@@ -3354,8 +3233,8 @@ inline void gcode_G0_G1(
 inline void gcode_G4() {
   millis_t dwell_ms = 0;
 
-  if (code_seen('P')) dwell_ms = code_value_millis(); // milliseconds to wait
-  if (code_seen('S')) dwell_ms = code_value_millis_from_seconds(); // seconds to wait
+  if (parser.seen('P')) dwell_ms = parser.value_millis(); // milliseconds to wait
+  if (parser.seen('S')) dwell_ms = parser.value_millis_from_seconds(); // seconds to wait
 
   stepper.synchronize();
   refresh_cmd_timeout();
@@ -3384,10 +3263,10 @@ inline void gcode_G4() {
       gcode_get_destination();
 
       const float offset[] = {
-        code_seen('I') ? code_value_linear_units() : 0.0,
-        code_seen('J') ? code_value_linear_units() : 0.0,
-        code_seen('P') ? code_value_linear_units() : 0.0,
-        code_seen('Q') ? code_value_linear_units() : 0.0
+        parser.seen('I') ? parser.value_linear_units() : 0.0,
+        parser.seen('J') ? parser.value_linear_units() : 0.0,
+        parser.seen('P') ? parser.value_linear_units() : 0.0,
+        parser.seen('Q') ? parser.value_linear_units() : 0.0
       };
 
       plan_cubic_move(offset);
@@ -3405,7 +3284,7 @@ inline void gcode_G4() {
   inline void gcode_G10_G11(bool doRetract=false) {
     #if EXTRUDERS > 1
       if (doRetract) {
-        retracted_swap[active_extruder] = (code_seen('S') && code_value_bool()); // checks for swap retract argument
+        retracted_swap[active_extruder] = (parser.seen('S') && parser.value_bool()); // checks for swap retract argument
       }
     #endif
     retract(doRetract
@@ -3425,10 +3304,10 @@ inline void gcode_G4() {
     // Don't allow nozzle cleaning without homing first
     if (axis_unhomed_error()) return;
 
-    const uint8_t pattern = code_seen('P') ? code_value_ushort() : 0,
-                  strokes = code_seen('S') ? code_value_ushort() : NOZZLE_CLEAN_STROKES,
-                  objects = code_seen('T') ? code_value_ushort() : NOZZLE_CLEAN_TRIANGLES;
-    const float radius = code_seen('R') ? code_value_float() : NOZZLE_CLEAN_CIRCLE_RADIUS;
+    const uint8_t pattern = parser.seen('P') ? parser.value_ushort() : 0,
+                  strokes = parser.seen('S') ? parser.value_ushort() : NOZZLE_CLEAN_STROKES,
+                  objects = parser.seen('T') ? parser.value_ushort() : NOZZLE_CLEAN_TRIANGLES;
+    const float radius = parser.seen('R') ? parser.value_float() : NOZZLE_CLEAN_CIRCLE_RADIUS;
 
     Nozzle::clean(pattern, strokes, radius, objects);
   }
@@ -3438,12 +3317,12 @@ inline void gcode_G4() {
   /**
    * G20: Set input mode to inches
    */
-  inline void gcode_G20() { set_input_linear_units(LINEARUNIT_INCH); }
+  inline void gcode_G20() { parser.set_input_linear_units(LINEARUNIT_INCH); }
 
   /**
    * G21: Set input mode to millimeters
    */
-  inline void gcode_G21() { set_input_linear_units(LINEARUNIT_MM); }
+  inline void gcode_G21() { parser.set_input_linear_units(LINEARUNIT_MM); }
 #endif
 
 #if ENABLED(NOZZLE_PARK_FEATURE)
@@ -3453,7 +3332,7 @@ inline void gcode_G4() {
   inline void gcode_G27() {
     // Don't allow nozzle parking without homing first
     if (axis_unhomed_error()) return;
-    Nozzle::park(code_seen('P') ? code_value_ushort() : 0);
+    Nozzle::park(parser.seen('P') ? parser.value_ushort() : 0);
   }
 #endif // NOZZLE_PARK_FEATURE
 
@@ -3770,9 +3649,9 @@ inline void gcode_G28(const bool always_home_all) {
 
   #else // NOT DELTA
 
-    const bool homeX = always_home_all || code_seen('X'),
-               homeY = always_home_all || code_seen('Y'),
-               homeZ = always_home_all || code_seen('Z'),
+    const bool homeX = always_home_all || parser.seen('X'),
+               homeY = always_home_all || parser.seen('Y'),
+               homeZ = always_home_all || parser.seen('Z'),
                home_all = (!homeX && !homeY && !homeZ) || (homeX && homeY && homeZ);
 
     set_destination_to_current();
@@ -4001,7 +3880,7 @@ void home_all_axes() { gcode_G28(true); }
       static bool enable_soft_endstops;
     #endif
 
-    const MeshLevelingState state = code_seen('S') ? (MeshLevelingState)code_value_byte() : MeshReport;
+    const MeshLevelingState state = parser.seen('S') ? (MeshLevelingState)parser.value_byte() : MeshReport;
     if (!WITHIN(state, 0, 5)) {
       SERIAL_PROTOCOLLNPGM("S out of range (0-5).");
       return;
@@ -4073,8 +3952,8 @@ void home_all_axes() { gcode_G28(true); }
         break;
 
       case MeshSet:
-        if (code_seen('X')) {
-          px = code_value_int() - 1;
+        if (parser.seen('X')) {
+          px = parser.value_int() - 1;
           if (!WITHIN(px, 0, GRID_MAX_POINTS_X - 1)) {
             SERIAL_PROTOCOLLNPGM("X out of range (1-" STRINGIFY(GRID_MAX_POINTS_X) ").");
             return;
@@ -4085,8 +3964,8 @@ void home_all_axes() { gcode_G28(true); }
           return;
         }
 
-        if (code_seen('Y')) {
-          py = code_value_int() - 1;
+        if (parser.seen('Y')) {
+          py = parser.value_int() - 1;
           if (!WITHIN(py, 0, GRID_MAX_POINTS_Y - 1)) {
             SERIAL_PROTOCOLLNPGM("Y out of range (1-" STRINGIFY(GRID_MAX_POINTS_Y) ").");
             return;
@@ -4097,8 +3976,8 @@ void home_all_axes() { gcode_G28(true); }
           return;
         }
 
-        if (code_seen('Z')) {
-          mbl.z_values[px][py] = code_value_linear_units();
+        if (parser.seen('Z')) {
+          mbl.z_values[px][py] = parser.value_linear_units();
         }
         else {
           SERIAL_CHAR('Z'); echo_not_entered();
@@ -4107,8 +3986,8 @@ void home_all_axes() { gcode_G28(true); }
         break;
 
       case MeshSetZOffset:
-        if (code_seen('Z')) {
-          mbl.z_offset = code_value_linear_units();
+        if (parser.seen('Z')) {
+          mbl.z_offset = parser.value_linear_units();
         }
         else {
           SERIAL_CHAR('Z'); echo_not_entered();
@@ -4213,7 +4092,7 @@ void home_all_axes() { gcode_G28(true); }
 
     // G29 Q is also available if debugging
     #if ENABLED(DEBUG_LEVELING_FEATURE)
-      const bool query = code_seen('Q');
+      const bool query = parser.seen('Q');
       const uint8_t old_debug_flags = marlin_debug_flags;
       if (query) marlin_debug_flags |= DEBUG_LEVELING;
       if (DEBUGGING(LEVELING)) {
@@ -4227,7 +4106,7 @@ void home_all_axes() { gcode_G28(true); }
     #endif
 
     #if ENABLED(DEBUG_LEVELING_FEATURE) && DISABLED(PROBE_MANUALLY)
-      const bool faux = code_seen('C') && code_value_bool();
+      const bool faux = parser.seen('C') && parser.value_bool();
     #else
       bool constexpr faux = false;
     #endif
@@ -4318,24 +4197,24 @@ void home_all_axes() { gcode_G28(true); }
 
       #if ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-        if (code_seen('W')) {
+        if (parser.seen('W')) {
           if (!bilinear_grid_spacing[X_AXIS]) {
             SERIAL_ERROR_START;
             SERIAL_ERRORLNPGM("No bilinear grid");
             return;
           }
 
-          const float z = code_seen('Z') && code_has_value() ? code_value_float() : 99999;
+          const float z = parser.seen('Z') && parser.has_value() ? parser.value_float() : 99999;
           if (!WITHIN(z, -10, 10)) {
             SERIAL_ERROR_START;
             SERIAL_ERRORLNPGM("Bad Z value");
             return;
           }
 
-          const float x = code_seen('X') && code_has_value() ? code_value_float() : 99999,
-                      y = code_seen('Y') && code_has_value() ? code_value_float() : 99999;
-          int8_t i = code_seen('I') && code_has_value() ? code_value_byte() : -1,
-                 j = code_seen('J') && code_has_value() ? code_value_byte() : -1;
+          const float x = parser.seen('X') && parser.has_value() ? parser.value_float() : 99999,
+                      y = parser.seen('Y') && parser.has_value() ? parser.value_float() : 99999;
+          int8_t i = parser.seen('I') && parser.has_value() ? parser.value_byte() : -1,
+                 j = parser.seen('J') && parser.has_value() ? parser.value_byte() : -1;
 
           if (x < 99998 && y < 99998) {
             // Get nearest i / j from x / y
@@ -4353,37 +4232,37 @@ void home_all_axes() { gcode_G28(true); }
             set_bed_leveling_enabled(abl_should_enable);
           }
           return;
-        } // code_seen('W')
+        } // parser.seen('W')
 
       #endif
 
       #if HAS_LEVELING
 
         // Jettison bed leveling data
-        if (code_seen('J')) {
+        if (parser.seen('J')) {
           reset_bed_level();
           return;
         }
 
       #endif
 
-      verbose_level = code_seen('V') && code_has_value() ? code_value_int() : 0;
+      verbose_level = parser.seen('V') && parser.has_value() ? parser.value_int() : 0;
       if (!WITHIN(verbose_level, 0, 4)) {
         SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).");
         return;
       }
 
-      dryrun = code_seen('D') && code_value_bool();
+      dryrun = parser.seen('D') && parser.value_bool();
 
       #if ENABLED(AUTO_BED_LEVELING_LINEAR)
 
-        do_topography_map = verbose_level > 2 || code_seen('T');
+        do_topography_map = verbose_level > 2 || parser.seen('T');
 
         // X and Y specify points in each direction, overriding the default
         // These values may be saved with the completed mesh
-        abl_grid_points_x = code_seen('X') ? code_value_int() : GRID_MAX_POINTS_X;
-        abl_grid_points_y = code_seen('Y') ? code_value_int() : GRID_MAX_POINTS_Y;
-        if (code_seen('P')) abl_grid_points_x = abl_grid_points_y = code_value_int();
+        abl_grid_points_x = parser.seen('X') ? parser.value_int() : GRID_MAX_POINTS_X;
+        abl_grid_points_y = parser.seen('Y') ? parser.value_int() : GRID_MAX_POINTS_Y;
+        if (parser.seen('P')) abl_grid_points_x = abl_grid_points_y = parser.value_int();
 
         if (abl_grid_points_x < 2 || abl_grid_points_y < 2) {
           SERIAL_PROTOCOLLNPGM("?Number of probe points is implausible (2 minimum).");
@@ -4394,18 +4273,18 @@ void home_all_axes() { gcode_G28(true); }
 
       #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
 
-        zoffset = code_seen('Z') ? code_value_linear_units() : 0;
+        zoffset = parser.seen('Z') ? parser.value_linear_units() : 0;
 
       #endif
 
       #if ABL_GRID
 
-        xy_probe_feedrate_mm_s = MMM_TO_MMS(code_seen('S') ? code_value_linear_units() : XY_PROBE_SPEED);
+        xy_probe_feedrate_mm_s = MMM_TO_MMS(parser.seen('S') ? parser.value_linear_units() : XY_PROBE_SPEED);
 
-        left_probe_bed_position = code_seen('L') ? (int)code_value_linear_units() : LOGICAL_X_POSITION(LEFT_PROBE_BED_POSITION);
-        right_probe_bed_position = code_seen('R') ? (int)code_value_linear_units() : LOGICAL_X_POSITION(RIGHT_PROBE_BED_POSITION);
-        front_probe_bed_position = code_seen('F') ? (int)code_value_linear_units() : LOGICAL_Y_POSITION(FRONT_PROBE_BED_POSITION);
-        back_probe_bed_position = code_seen('B') ? (int)code_value_linear_units() : LOGICAL_Y_POSITION(BACK_PROBE_BED_POSITION);
+        left_probe_bed_position = parser.seen('L') ? (int)parser.value_linear_units() : LOGICAL_X_POSITION(LEFT_PROBE_BED_POSITION);
+        right_probe_bed_position = parser.seen('R') ? (int)parser.value_linear_units() : LOGICAL_X_POSITION(RIGHT_PROBE_BED_POSITION);
+        front_probe_bed_position = parser.seen('F') ? (int)parser.value_linear_units() : LOGICAL_Y_POSITION(FRONT_PROBE_BED_POSITION);
+        back_probe_bed_position = parser.seen('B') ? (int)parser.value_linear_units() : LOGICAL_Y_POSITION(BACK_PROBE_BED_POSITION);
 
         const bool left_out_l = left_probe_bed_position < LOGICAL_X_POSITION(MIN_PROBE_X),
                    left_out = left_out_l || left_probe_bed_position > right_probe_bed_position - (MIN_PROBE_EDGE),
@@ -4519,7 +4398,7 @@ void home_all_axes() { gcode_G28(true); }
     #if ENABLED(PROBE_MANUALLY)
 
       // Abort current G29 procedure, go back to ABLStart
-      if (code_seen('A') && g29_in_progress) {
+      if (parser.seen('A') && g29_in_progress) {
         SERIAL_PROTOCOLLNPGM("Manual G29 aborted");
         #if HAS_SOFTWARE_ENDSTOPS
           soft_endstops_enabled = enable_soft_endstops;
@@ -4529,7 +4408,7 @@ void home_all_axes() { gcode_G28(true); }
       }
 
       // Query G29 status
-      if (code_seen('Q')) {
+      if (parser.seen('Q')) {
         if (!g29_in_progress)
           SERIAL_PROTOCOLLNPGM("Manual G29 idle");
         else {
@@ -4538,7 +4417,7 @@ void home_all_axes() { gcode_G28(true); }
         }
       }
 
-      if (code_seen('A') || code_seen('Q')) return;
+      if (parser.seen('A') || parser.seen('Q')) return;
 
       // Fall through to probe the first point
       g29_in_progress = true;
@@ -4674,7 +4553,7 @@ void home_all_axes() { gcode_G28(true); }
 
     #else // !PROBE_MANUALLY
 
-      bool stow_probe_after_each = code_seen('E');
+      const bool stow_probe_after_each = parser.seen('E');
 
       #if ABL_GRID
 
@@ -5015,8 +4894,8 @@ void home_all_axes() { gcode_G28(true); }
    *   S0  Leave the probe deployed
    */
   inline void gcode_G30() {
-    const float xpos = code_seen('X') ? code_value_linear_units() : current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER,
-                ypos = code_seen('Y') ? code_value_linear_units() : current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER;
+    const float xpos = parser.seen('X') ? parser.value_linear_units() : current_position[X_AXIS] + X_PROBE_OFFSET_FROM_EXTRUDER,
+                ypos = parser.seen('Y') ? parser.value_linear_units() : current_position[Y_AXIS] + Y_PROBE_OFFSET_FROM_EXTRUDER;
 
     if (!position_is_reachable_by_probe_xy(xpos, ypos)) return;
 
@@ -5027,7 +4906,7 @@ void home_all_axes() { gcode_G28(true); }
 
     setup_for_endstop_or_probe_move();
 
-    const float measured_z = probe_pt(xpos, ypos, !code_seen('S') || code_value_bool(), 1);
+    const float measured_z = probe_pt(xpos, ypos, !parser.seen('S') || parser.value_bool(), 1);
 
     if (!isnan(measured_z)) {
       SERIAL_PROTOCOLPAIR("Bed X: ", FIXFLOAT(xpos));
@@ -5080,25 +4959,25 @@ void home_all_axes() { gcode_G28(true); }
      */
     inline void gcode_G33() {
 
-      const int8_t probe_points = code_seen('P') ? code_value_int() : DELTA_CALIBRATION_DEFAULT_POINTS;
+      const int8_t probe_points = parser.seen('P') ? parser.value_int() : DELTA_CALIBRATION_DEFAULT_POINTS;
       if (!WITHIN(probe_points, 1, 7)) {
         SERIAL_PROTOCOLLNPGM("?(P)oints is implausible (1 to 7).");
         return;
       }
 
-      const int8_t verbose_level = code_seen('V') ? code_value_byte() : 1;
+      const int8_t verbose_level = parser.seen('V') ? parser.value_byte() : 1;
       if (!WITHIN(verbose_level, 0, 2)) {
         SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-2).");
         return;
       }
 
-      const float calibration_precision = code_seen('C') ? code_value_float() : 0.0;
+      const float calibration_precision = parser.seen('C') ? parser.value_float() : 0.0;
       if (calibration_precision < 0) {
         SERIAL_PROTOCOLLNPGM("?(C)alibration precision is implausible (>0).");
         return;
       }
 
-      const bool towers_set = !code_seen('T'),
+      const bool towers_set = !parser.seen('T'),
                  _1p_calibration      = probe_points == 1,
                  _4p_calibration      = probe_points == 2,
                  _4p_towers_points    = _4p_calibration && towers_set,
@@ -5537,7 +5416,7 @@ void home_all_axes() { gcode_G28(true); }
     // If any axis has enough movement, do the move
     LOOP_XYZ(i)
       if (fabs(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
-        if (!code_seen('F')) feedrate_mm_s = homing_feedrate_mm_s[i];
+        if (!parser.seen('F')) feedrate_mm_s = homing_feedrate_mm_s[i];
         // If G38.2 fails throw an error
         if (!G38_run_probe() && is_38_2) {
           SERIAL_ERROR_START;
@@ -5558,10 +5437,10 @@ void home_all_axes() { gcode_G28(true); }
    */
   inline void gcode_G42() {
     if (IsRunning()) {
-      const bool hasI = code_seen('I');
-      const int8_t ix = code_has_value() ? code_value_int() : 0;
-      const bool hasJ = code_seen('J');
-      const int8_t iy = code_has_value() ? code_value_int() : 0;
+      const bool hasI = parser.seen('I');
+      const int8_t ix = parser.has_value() ? parser.value_int() : 0;
+      const bool hasJ = parser.seen('J');
+      const int8_t iy = parser.has_value() ? parser.value_int() : 0;
 
       if ((hasI && !WITHIN(ix, 0, GRID_MAX_POINTS_X - 1)) || (hasJ && !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1))) {
         SERIAL_ECHOLNPGM(MSG_ERR_MESH_XY);
@@ -5582,13 +5461,13 @@ void home_all_axes() { gcode_G28(true); }
       set_destination_to_current();
       if (hasI) destination[X_AXIS] = LOGICAL_X_POSITION(_GET_MESH_X(ix));
       if (hasJ) destination[Y_AXIS] = LOGICAL_Y_POSITION(_GET_MESH_Y(iy));
-      if (code_seen('P') && code_value_bool()) {
+      if (parser.seen('P') && parser.value_bool()) {
         if (hasI) destination[X_AXIS] -= X_PROBE_OFFSET_FROM_EXTRUDER;
         if (hasJ) destination[Y_AXIS] -= Y_PROBE_OFFSET_FROM_EXTRUDER;
       }
 
-      if (code_seen('F') && code_value_linear_units() > 0.0)
-        feedrate_mm_s = MMM_TO_MMS(code_value_linear_units());
+      if (parser.seen('F') && parser.value_linear_units() > 0.0)
+        feedrate_mm_s = MMM_TO_MMS(parser.value_linear_units());
 
       // SCARA kinematic has "safe" XY raw moves
       #if IS_SCARA
@@ -5606,20 +5485,20 @@ void home_all_axes() { gcode_G28(true); }
  */
 inline void gcode_G92() {
   bool didXYZ = false,
-       didE = code_seen('E');
+       didE = parser.seen('E');
 
   if (!didE) stepper.synchronize();
 
   LOOP_XYZE(i) {
-    if (code_seen(axis_codes[i])) {
+    if (parser.seen(axis_codes[i])) {
       #if IS_SCARA
-        current_position[i] = code_value_axis_units((AxisEnum)i);
+        current_position[i] = parser.value_axis_units((AxisEnum)i);
         if (i != E_AXIS) didXYZ = true;
       #else
         #if HAS_POSITION_SHIFT
           const float p = current_position[i];
         #endif
-        float v = code_value_axis_units((AxisEnum)i);
+        float v = parser.value_axis_units((AxisEnum)i);
 
         current_position[i] = v;
 
@@ -5648,22 +5527,22 @@ inline void gcode_G92() {
    * M1: Conditional stop   - Wait for user button press on LCD
    */
   inline void gcode_M0_M1() {
-    const char * const args = current_command_args;
+    const char * const args = parser.string_arg;
 
-    millis_t codenum = 0;
+    millis_t ms = 0;
     bool hasP = false, hasS = false;
-    if (code_seen('P')) {
-      codenum = code_value_millis(); // milliseconds to wait
-      hasP = codenum > 0;
+    if (parser.seen('P')) {
+      ms = parser.value_millis(); // milliseconds to wait
+      hasP = ms > 0;
     }
-    if (code_seen('S')) {
-      codenum = code_value_millis_from_seconds(); // seconds to wait
-      hasS = codenum > 0;
+    if (parser.seen('S')) {
+      ms = parser.value_millis_from_seconds(); // seconds to wait
+      hasS = ms > 0;
     }
 
     #if ENABLED(ULTIPANEL)
 
-      if (!hasP && !hasS && *args != '\0')
+      if (!hasP && !hasS && args && *args)
         lcd_setstatus(args, true);
       else {
         LCD_MESSAGEPGM(MSG_USERWAIT);
@@ -5674,7 +5553,7 @@ inline void gcode_G92() {
 
     #else
 
-      if (!hasP && !hasS && *args != '\0') {
+      if (!hasP && !hasS && args && *args) {
         SERIAL_ECHO_START;
         SERIAL_ECHOLN(args);
       }
@@ -5687,9 +5566,9 @@ inline void gcode_G92() {
     stepper.synchronize();
     refresh_cmd_timeout();
 
-    if (codenum > 0) {
-      codenum += previous_cmd_ms;  // wait until this time for a click
-      while (PENDING(millis(), codenum) && wait_for_user) idle();
+    if (ms > 0) {
+      ms += previous_cmd_ms;  // wait until this time for a click
+      while (PENDING(millis(), ms) && wait_for_user) idle();
     }
     else {
       #if ENABLED(ULTIPANEL)
@@ -5759,7 +5638,7 @@ inline void gcode_G92() {
    */
 
   inline void ocr_val_mode() {
-    uint8_t spindle_laser_power = code_value_byte();
+    uint8_t spindle_laser_power = parser.value_byte();
     WRITE(SPINDLE_LASER_ENABLE_PIN, SPINDLE_LASER_ENABLE_INVERT); // turn spindle on (active low)
     if (SPINDLE_LASER_PWM_INVERT) spindle_laser_power = 255 - spindle_laser_power;
     analogWrite(SPINDLE_LASER_PWM_PIN, spindle_laser_power);
@@ -5786,9 +5665,9 @@ inline void gcode_G92() {
      * Then needed to AND the uint16_t result with 0x00FF to make sure we only wrote the byte of interest.
      */
     #if ENABLED(SPINDLE_LASER_PWM)
-      if (code_seen('O')) ocr_val_mode();
+      if (parser.seen('O')) ocr_val_mode();
       else {
-        const float spindle_laser_power = code_seen('S') ? code_value_float() : 0;
+        const float spindle_laser_power = parser.seen('S') ? parser.value_float() : 0;
         if (spindle_laser_power == 0) {
           WRITE(SPINDLE_LASER_ENABLE_PIN, !SPINDLE_LASER_ENABLE_INVERT);                                    // turn spindle off (active low)
           delay_for_power_down();
@@ -5895,7 +5774,7 @@ inline void gcode_M17() {
   /**
    * M23: Open a file
    */
-  inline void gcode_M23() { card.openFile(current_command_args, true); }
+  inline void gcode_M23() { card.openFile(parser.string_arg, true); }
 
   /**
    * M24: Start or Resume SD Print
@@ -5925,8 +5804,8 @@ inline void gcode_M17() {
    * M26: Set SD Card file index
    */
   inline void gcode_M26() {
-    if (card.cardOK && code_seen('S'))
-      card.setIndex(code_value_long());
+    if (card.cardOK && parser.seen('S'))
+      card.setIndex(parser.value_long());
   }
 
   /**
@@ -5937,7 +5816,7 @@ inline void gcode_M17() {
   /**
    * M28: Start SD Write
    */
-  inline void gcode_M28() { card.openFile(current_command_args, false); }
+  inline void gcode_M28() { card.openFile(parser.string_arg, false); }
 
   /**
    * M29: Stop SD Write
@@ -5953,7 +5832,7 @@ inline void gcode_M17() {
   inline void gcode_M30() {
     if (card.cardOK) {
       card.closefile();
-      card.removeFile(current_command_args);
+      card.removeFile(parser.string_arg);
     }
   }
 
@@ -5977,23 +5856,18 @@ inline void gcode_M31() {
   /**
    * M32: Select file and start SD Print
    */
-  inline void gcode_M32() {  // Why is M32 allowed to flout the sacred GCode standard?
+  inline void gcode_M32() {
     if (card.sdprinting)
       stepper.synchronize();
 
-    char* namestartpos = strchr(current_command_args, '!');  // Find ! to indicate filename string start.
-    if (!namestartpos)
-      namestartpos = current_command_args; // Default name position, 4 letters after the M
-    else
-      namestartpos++; //to skip the '!'
-
-    bool call_procedure = code_seen('P') && (seen_pointer < namestartpos);
+    char* namestartpos = parser.string_arg;
+    bool call_procedure = parser.seen('P');
 
     if (card.cardOK) {
       card.openFile(namestartpos, true, call_procedure);
 
-      if (code_seen('S') && seen_pointer < namestartpos) // "S" (must occur _before_ the filename!)
-        card.setIndex(code_value_long());
+      if (parser.seen('S'))
+        card.setIndex(parser.value_long());
 
       card.startFileprint();
 
@@ -6017,7 +5891,7 @@ inline void gcode_M31() {
      *   /Miscellaneous/Armchair/Armchair.gcode
      */
     inline void gcode_M33() {
-      card.printLongPath(current_command_args);
+      card.printLongPath(parser.string_arg);
     }
 
   #endif
@@ -6027,12 +5901,12 @@ inline void gcode_M31() {
      * M34: Set SD Card Sorting Options
      */
     inline void gcode_M34() {
-      if (code_seen('S')) card.setSortOn(code_value_bool());
-      if (code_seen('F')) {
-        int v = code_value_long();
+      if (parser.seen('S')) card.setSortOn(parser.value_bool());
+      if (parser.seen('F')) {
+        int v = parser.value_long();
         card.setSortFolders(v < 0 ? -1 : v > 0 ? 1 : 0);
       }
-      //if (code_seen('R')) card.setSortReverse(code_value_bool());
+      //if (parser.seen('R')) card.setSortReverse(parser.value_bool());
     }
   #endif // SDCARD_SORT_ALPHA && SDSORT_GCODE
 
@@ -6040,7 +5914,7 @@ inline void gcode_M31() {
    * M928: Start SD Write
    */
   inline void gcode_M928() {
-    card.openLogFile(current_command_args);
+    card.openLogFile(parser.string_arg);
   }
 
 #endif // SDSUPPORT
@@ -6062,12 +5936,12 @@ static bool pin_is_protected(uint8_t pin) {
  *  S<byte> Pin status from 0 - 255
  */
 inline void gcode_M42() {
-  if (!code_seen('S')) return;
+  if (!parser.seen('S')) return;
 
-  int pin_status = code_value_int();
+  int pin_status = parser.value_int();
   if (!WITHIN(pin_status, 0, 255)) return;
 
-  int pin_number = code_seen('P') ? code_value_int() : LED_PIN;
+  int pin_number = parser.seen('P') ? parser.value_int() : LED_PIN;
   if (pin_number < 0) return;
 
   if (pin_is_protected(pin_number)) {
@@ -6100,11 +5974,11 @@ inline void gcode_M42() {
   #include "pinsDebug.h"
 
   inline void toggle_pins() {
-    const bool I_flag = code_seen('I') && code_value_bool();
-    const int repeat = code_seen('R') ? code_value_int() : 1,
-              start = code_seen('S') ? code_value_int() : 0,
-              end = code_seen('E') ? code_value_int() : NUM_DIGITAL_PINS - 1,
-              wait = code_seen('W') ? code_value_int() : 500;
+    const bool I_flag = parser.seen('I') && parser.value_bool();
+    const int repeat = parser.seen('R') ? parser.value_int() : 1,
+              start = parser.seen('S') ? parser.value_int() : 0,
+              end = parser.seen('E') ? parser.value_int() : NUM_DIGITAL_PINS - 1,
+              wait = parser.seen('W') ? parser.value_int() : 500;
 
     for (uint8_t pin = start; pin <= end; pin++) {
       if (!I_flag && pin_is_protected(pin)) {
@@ -6142,7 +6016,7 @@ inline void gcode_M42() {
 
     #else
 
-      const uint8_t probe_index = code_seen('P') ? code_value_byte() : Z_ENDSTOP_SERVO_NR;
+      const uint8_t probe_index = parser.seen('P') ? parser.value_byte() : Z_ENDSTOP_SERVO_NR;
 
       SERIAL_PROTOCOLLNPGM("Servo probe test");
       SERIAL_PROTOCOLLNPAIR(".  using index:  ", probe_index);
@@ -6284,35 +6158,35 @@ inline void gcode_M42() {
    */
   inline void gcode_M43() {
 
-    if (code_seen('T')) {   // must be first ot else it's "S" and "E" parameters will execute endstop or servo test
+    if (parser.seen('T')) {   // must be first ot else it's "S" and "E" parameters will execute endstop or servo test
       toggle_pins();
       return;
     }
 
     // Enable or disable endstop monitoring
-    if (code_seen('E')) {
-      endstop_monitor_flag = code_value_bool();
+    if (parser.seen('E')) {
+      endstop_monitor_flag = parser.value_bool();
       SERIAL_PROTOCOLPGM("endstop monitor ");
       SERIAL_PROTOCOL(endstop_monitor_flag ? "en" : "dis");
       SERIAL_PROTOCOLLNPGM("abled");
       return;
     }
 
-    if (code_seen('S')) {
+    if (parser.seen('S')) {
       servo_probe_test();
       return;
     }
 
     // Get the range of pins to test or watch
-    const uint8_t first_pin = code_seen('P') ? code_value_byte() : 0,
-                  last_pin = code_seen('P') ? first_pin : NUM_DIGITAL_PINS - 1;
+    const uint8_t first_pin = parser.seen('P') ? parser.value_byte() : 0,
+                  last_pin = parser.seen('P') ? first_pin : NUM_DIGITAL_PINS - 1;
 
     if (first_pin > last_pin) return;
 
-    const bool ignore_protection = code_seen('I') && code_value_bool();
+    const bool ignore_protection = parser.seen('I') && parser.value_bool();
 
     // Watch until click, M108, or reset
-    if (code_seen('W') && code_value_bool()) {
+    if (parser.seen('W') && parser.value_bool()) {
       SERIAL_PROTOCOLLNPGM("Watching pins");
       byte pin_state[last_pin - first_pin + 1];
       for (int8_t pin = first_pin; pin <= last_pin; pin++) {
@@ -6390,7 +6264,7 @@ inline void gcode_M42() {
 
     if (axis_unhomed_error()) return;
 
-    const int8_t verbose_level = code_seen('V') ? code_value_byte() : 1;
+    const int8_t verbose_level = parser.seen('V') ? parser.value_byte() : 1;
     if (!WITHIN(verbose_level, 0, 4)) {
       SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).");
       return;
@@ -6399,19 +6273,19 @@ inline void gcode_M42() {
     if (verbose_level > 0)
       SERIAL_PROTOCOLLNPGM("M48 Z-Probe Repeatability Test");
 
-    int8_t n_samples = code_seen('P') ? code_value_byte() : 10;
+    int8_t n_samples = parser.seen('P') ? parser.value_byte() : 10;
     if (!WITHIN(n_samples, 4, 50)) {
       SERIAL_PROTOCOLLNPGM("?Sample size not plausible (4-50).");
       return;
     }
 
+    const bool stow_probe_after_each = parser.seen('E');
+
     float X_current = current_position[X_AXIS],
           Y_current = current_position[Y_AXIS];
 
-    bool stow_probe_after_each = code_seen('E');
-
-    const float X_probe_location = code_seen('X') ? code_value_linear_units() : X_current + X_PROBE_OFFSET_FROM_EXTRUDER,
-                Y_probe_location = code_seen('Y') ? code_value_linear_units() : Y_current + Y_PROBE_OFFSET_FROM_EXTRUDER;
+    const float X_probe_location = parser.seen('X') ? parser.value_linear_units() : X_current + X_PROBE_OFFSET_FROM_EXTRUDER,
+                Y_probe_location = parser.seen('Y') ? parser.value_linear_units() : Y_current + Y_PROBE_OFFSET_FROM_EXTRUDER;
 
     #if DISABLED(DELTA)
       if (!WITHIN(X_probe_location, LOGICAL_X_POSITION(MIN_PROBE_X), LOGICAL_X_POSITION(MAX_PROBE_X))) {
@@ -6429,15 +6303,15 @@ inline void gcode_M42() {
       }
     #endif
 
-    bool seen_L = code_seen('L');
-    uint8_t n_legs = seen_L ? code_value_byte() : 0;
+    bool seen_L = parser.seen('L');
+    uint8_t n_legs = seen_L ? parser.value_byte() : 0;
     if (n_legs > 15) {
       SERIAL_PROTOCOLLNPGM("?Number of legs in movement not plausible (0-15).");
       return;
     }
     if (n_legs == 1) n_legs = 2;
 
-    bool schizoid_flag = code_seen('S');
+    bool schizoid_flag = parser.seen('S');
     if (schizoid_flag && !seen_L) n_legs = 7;
 
     /**
@@ -6653,7 +6527,7 @@ inline void gcode_M77() { print_job_timer.stop(); }
    */
   inline void gcode_M78() {
     // "M78 S78" will reset the statistics
-    if (code_seen('S') && code_value_int() == 78)
+    if (parser.seen('S') && parser.value_int() == 78)
       print_job_timer.initStats();
     else
       print_job_timer.showStats();
@@ -6671,8 +6545,8 @@ inline void gcode_M104() {
     if (target_extruder != active_extruder) return;
   #endif
 
-  if (code_seen('S')) {
-    const int16_t temp = code_value_temp_abs();
+  if (parser.seen('S')) {
+    const int16_t temp = parser.value_celsius();
     thermalManager.setTargetHotend(temp, target_extruder);
 
     #if ENABLED(DUAL_X_CARRIAGE)
@@ -6687,13 +6561,13 @@ inline void gcode_M104() {
        * standby mode, for instance in a dual extruder setup, without affecting
        * the running print timer.
        */
-      if (code_value_temp_abs() <= (EXTRUDE_MINTEMP) / 2) {
+      if (parser.value_celsius() <= (EXTRUDE_MINTEMP) / 2) {
         print_job_timer.stop();
         LCD_MESSAGEPGM(WELCOME_MSG);
       }
     #endif
 
-    if (code_value_temp_abs() > thermalManager.degHotend(target_extruder))
+    if (parser.value_celsius() > thermalManager.degHotend(target_extruder))
       lcd_status_printf_P(0, PSTR("E%i %s"), target_extruder + 1, MSG_HEATING);
   }
 
@@ -6780,8 +6654,8 @@ inline void gcode_M105() {
    * M155: Set temperature auto-report interval. M155 S<seconds>
    */
   inline void gcode_M155() {
-    if (code_seen('S')) {
-      auto_report_temp_interval = code_value_byte();
+    if (parser.seen('S')) {
+      auto_report_temp_interval = parser.value_byte();
       NOMORE(auto_report_temp_interval, 60);
       next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval;
     }
@@ -6806,8 +6680,8 @@ inline void gcode_M105() {
    *  P<index> Fan index, if more than one fan
    */
   inline void gcode_M106() {
-    uint16_t s = code_seen('S') ? code_value_ushort() : 255,
-             p = code_seen('P') ? code_value_ushort() : 0;
+    uint16_t s = parser.seen('S') ? parser.value_ushort() : 255,
+             p = parser.seen('P') ? parser.value_ushort() : 0;
     NOMORE(s, 255);
     if (p < FAN_COUNT) fanSpeeds[p] = s;
   }
@@ -6816,7 +6690,7 @@ inline void gcode_M105() {
    * M107: Fan Off
    */
   inline void gcode_M107() {
-    uint16_t p = code_seen('P') ? code_value_ushort() : 0;
+    uint16_t p = parser.seen('P') ? parser.value_ushort() : 0;
     if (p < FAN_COUNT) fanSpeeds[p] = 0;
   }
 
@@ -6867,9 +6741,9 @@ inline void gcode_M109() {
     if (target_extruder != active_extruder) return;
   #endif
 
-  const bool no_wait_for_cooling = code_seen('S');
-  if (no_wait_for_cooling || code_seen('R')) {
-    const int16_t temp = code_value_temp_abs();
+  const bool no_wait_for_cooling = parser.seen('S');
+  if (no_wait_for_cooling || parser.seen('R')) {
+    const int16_t temp = parser.value_celsius();
     thermalManager.setTargetHotend(temp, target_extruder);
 
     #if ENABLED(DUAL_X_CARRIAGE)
@@ -6883,7 +6757,7 @@ inline void gcode_M109() {
        * standby mode, (e.g., in a dual extruder setup) without affecting
        * the running print timer.
        */
-      if (code_value_temp_abs() <= (EXTRUDE_MINTEMP) / 2) {
+      if (parser.value_celsius() <= (EXTRUDE_MINTEMP) / 2) {
         print_job_timer.stop();
         LCD_MESSAGEPGM(WELCOME_MSG);
       }
@@ -7020,12 +6894,11 @@ inline void gcode_M109() {
     if (DEBUGGING(DRYRUN)) return;
 
     LCD_MESSAGEPGM(MSG_BED_HEATING);
-    const bool no_wait_for_cooling = code_seen('S');
-    if (no_wait_for_cooling || code_seen('R')) {
-      thermalManager.setTargetBed(code_value_temp_abs());
-
+    const bool no_wait_for_cooling = parser.seen('S');
+    if (no_wait_for_cooling || parser.seen('R')) {
+      thermalManager.setTargetBed(parser.value_celsius());
       #if ENABLED(PRINTJOB_TIMER_AUTOSTART)
-        if (code_value_temp_abs() > BED_MINTEMP)
+        if (parser.value_celsius() > BED_MINTEMP)
           print_job_timer.start();
       #endif
     }
@@ -7133,14 +7006,14 @@ inline void gcode_M109() {
  * M110: Set Current Line Number
  */
 inline void gcode_M110() {
-  if (code_seen('N')) gcode_LastN = code_value_long();
+  if (parser.seen('N')) gcode_LastN = parser.value_long();
 }
 
 /**
  * M111: Set the debug level
  */
 inline void gcode_M111() {
-  marlin_debug_flags = code_seen('S') ? code_value_byte() : (uint8_t)DEBUG_NONE;
+  marlin_debug_flags = parser.seen('S') ? parser.value_byte() : (uint8_t)DEBUG_NONE;
 
   const static char str_debug_1[] PROGMEM = MSG_DEBUG_ECHO;
   const static char str_debug_2[] PROGMEM = MSG_DEBUG_INFO;
@@ -7152,9 +7025,9 @@ inline void gcode_M111() {
   #endif
 
   const static char* const debug_strings[] PROGMEM = {
-    str_debug_1, str_debug_2, str_debug_4, str_debug_8, str_debug_16,
+    str_debug_1, str_debug_2, str_debug_4, str_debug_8, str_debug_16
     #if ENABLED(DEBUG_LEVELING_FEATURE)
-      str_debug_32
+      , str_debug_32
     #endif
   };
 
@@ -7183,8 +7056,8 @@ inline void gcode_M111() {
    *   S<seconds> Optional. Set the keepalive interval.
    */
   inline void gcode_M113() {
-    if (code_seen('S')) {
-      host_keepalive_interval = code_value_byte();
+    if (parser.seen('S')) {
+      host_keepalive_interval = parser.value_byte();
       NOMORE(host_keepalive_interval, 60);
     }
     else {
@@ -7201,7 +7074,7 @@ inline void gcode_M111() {
     /**
      * M126: Heater 1 valve open
      */
-    inline void gcode_M126() { baricuda_valve_pressure = code_seen('S') ? code_value_byte() : 255; }
+    inline void gcode_M126() { baricuda_valve_pressure = parser.seen('S') ? parser.value_byte() : 255; }
     /**
      * M127: Heater 1 valve close
      */
@@ -7212,7 +7085,7 @@ inline void gcode_M111() {
     /**
      * M128: Heater 2 valve open
      */
-    inline void gcode_M128() { baricuda_e_to_p_pressure = code_seen('S') ? code_value_byte() : 255; }
+    inline void gcode_M128() { baricuda_e_to_p_pressure = parser.seen('S') ? parser.value_byte() : 255; }
     /**
      * M129: Heater 2 valve close
      */
@@ -7226,7 +7099,7 @@ inline void gcode_M111() {
  */
 inline void gcode_M140() {
   if (DEBUGGING(DRYRUN)) return;
-  if (code_seen('S')) thermalManager.setTargetBed(code_value_temp_abs());
+  if (parser.seen('S')) thermalManager.setTargetBed(parser.value_celsius());
 }
 
 #if ENABLED(ULTIPANEL)
@@ -7240,24 +7113,24 @@ inline void gcode_M140() {
    *   F<fan speed>
    */
   inline void gcode_M145() {
-    uint8_t material = code_seen('S') ? (uint8_t)code_value_int() : 0;
+    uint8_t material = parser.seen('S') ? (uint8_t)parser.value_int() : 0;
     if (material >= COUNT(lcd_preheat_hotend_temp)) {
       SERIAL_ERROR_START;
       SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX);
     }
     else {
       int v;
-      if (code_seen('H')) {
-        v = code_value_int();
+      if (parser.seen('H')) {
+        v = parser.value_int();
         lcd_preheat_hotend_temp[material] = constrain(v, EXTRUDE_MINTEMP, HEATER_0_MAXTEMP - 15);
       }
-      if (code_seen('F')) {
-        v = code_value_int();
+      if (parser.seen('F')) {
+        v = parser.value_int();
         lcd_preheat_fan_speed[material] = constrain(v, 0, 255);
       }
       #if TEMP_SENSOR_BED != 0
-        if (code_seen('B')) {
-          v = code_value_int();
+        if (parser.seen('B')) {
+          v = parser.value_int();
           lcd_preheat_bed_temp[material] = constrain(v, BED_MINTEMP, BED_MAXTEMP - 15);
         }
       #endif
@@ -7271,9 +7144,9 @@ inline void gcode_M140() {
    * M149: Set temperature units
    */
   inline void gcode_M149() {
-         if (code_seen('C')) set_input_temp_units(TEMPUNIT_C);
-    else if (code_seen('K')) set_input_temp_units(TEMPUNIT_K);
-    else if (code_seen('F')) set_input_temp_units(TEMPUNIT_F);
+         if (parser.seen('C')) parser.set_input_temp_units(TEMPUNIT_C);
+    else if (parser.seen('K')) parser.set_input_temp_units(TEMPUNIT_K);
+    else if (parser.seen('F')) parser.set_input_temp_units(TEMPUNIT_F);
   }
 #endif
 
@@ -7286,7 +7159,7 @@ inline void gcode_M140() {
   inline void gcode_M80() {
 
     // S: Report the current power supply state and exit
-    if (code_seen('S')) {
+    if (parser.seen('S')) {
       serialprintPGM(powersupply_on ? PSTR("PS:1\n") : PSTR("PS:0\n"));
       return;
     }
@@ -7362,21 +7235,21 @@ inline void gcode_M83() { axis_relative_modes[E_AXIS] = true; }
  * M18, M84: Disable stepper motors
  */
 inline void gcode_M18_M84() {
-  if (code_seen('S')) {
-    stepper_inactive_time = code_value_millis_from_seconds();
+  if (parser.seen('S')) {
+    stepper_inactive_time = parser.value_millis_from_seconds();
   }
   else {
-    bool all_axis = !((code_seen('X')) || (code_seen('Y')) || (code_seen('Z')) || (code_seen('E')));
+    bool all_axis = !((parser.seen('X')) || (parser.seen('Y')) || (parser.seen('Z')) || (parser.seen('E')));
     if (all_axis) {
       stepper.finish_and_disable();
     }
     else {
       stepper.synchronize();
-      if (code_seen('X')) disable_X();
-      if (code_seen('Y')) disable_Y();
-      if (code_seen('Z')) disable_Z();
+      if (parser.seen('X')) disable_X();
+      if (parser.seen('Y')) disable_Y();
+      if (parser.seen('Z')) disable_Z();
       #if ((E0_ENABLE_PIN != X_ENABLE_PIN) && (E1_ENABLE_PIN != Y_ENABLE_PIN)) // Only enable on boards that have seperate ENABLE_PINS
-        if (code_seen('E')) disable_e_steppers();
+        if (parser.seen('E')) disable_e_steppers();
       #endif
     }
   }
@@ -7386,7 +7259,7 @@ inline void gcode_M18_M84() {
  * M85: Set inactivity shutdown timer with parameter S<seconds>. To disable set zero (default)
  */
 inline void gcode_M85() {
-  if (code_seen('S')) max_inactive_time = code_value_millis_from_seconds();
+  if (parser.seen('S')) max_inactive_time = parser.value_millis_from_seconds();
 }
 
 /**
@@ -7411,9 +7284,9 @@ inline void gcode_M92() {
   GET_TARGET_EXTRUDER(92);
 
   LOOP_XYZE(i) {
-    if (code_seen(axis_codes[i])) {
+    if (parser.seen(axis_codes[i])) {
       if (i == E_AXIS) {
-        const float value = code_value_per_axis_unit((AxisEnum)(E_AXIS + TARGET_EXTRUDER));
+        const float value = parser.value_per_axis_unit((AxisEnum)(E_AXIS + TARGET_EXTRUDER));
         if (value < 20.0) {
           float factor = planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] / value; // increase e constants if M92 E14 is given for netfab.
           planner.max_jerk[E_AXIS] *= factor;
@@ -7423,7 +7296,7 @@ inline void gcode_M92() {
         planner.axis_steps_per_mm[E_AXIS + TARGET_EXTRUDER] = value;
       }
       else {
-        planner.axis_steps_per_mm[i] = code_value_per_axis_unit((AxisEnum)i);
+        planner.axis_steps_per_mm[i] = parser.value_per_axis_unit((AxisEnum)i);
       }
     }
   }
@@ -7531,7 +7404,7 @@ inline void gcode_M115() {
  * M117: Set LCD Status Message
  */
 inline void gcode_M117() {
-  lcd_setstatus(current_command_args);
+  lcd_setstatus(parser.string_arg);
 }
 
 /**
@@ -7592,7 +7465,7 @@ inline void gcode_M121() { endstops.enable_globally(false); }
     set_destination_to_current();
 
     // Initial retract before move to filament change position
-    destination[E_AXIS] += code_seen('L') ? code_value_axis_units(E_AXIS) : 0
+    destination[E_AXIS] += parser.seen('L') ? parser.value_axis_units(E_AXIS) : 0
       #if defined(FILAMENT_CHANGE_RETRACT_LENGTH) && FILAMENT_CHANGE_RETRACT_LENGTH > 0
         - (FILAMENT_CHANGE_RETRACT_LENGTH)
       #endif
@@ -7600,7 +7473,7 @@ inline void gcode_M121() { endstops.enable_globally(false); }
     RUNPLAN(FILAMENT_CHANGE_RETRACT_FEEDRATE);
 
     // Lift Z axis
-    const float z_lift = code_seen('Z') ? code_value_linear_units() :
+    const float z_lift = parser.seen('Z') ? parser.value_linear_units() :
       #if defined(FILAMENT_CHANGE_Z_ADD) && FILAMENT_CHANGE_Z_ADD > 0
         FILAMENT_CHANGE_Z_ADD
       #else
@@ -7614,12 +7487,12 @@ inline void gcode_M121() { endstops.enable_globally(false); }
     }
 
     // Move XY axes to filament change position or given position
-    destination[X_AXIS] = code_seen('X') ? code_value_linear_units() : 0
+    destination[X_AXIS] = parser.seen('X') ? parser.value_linear_units() : 0
       #ifdef FILAMENT_CHANGE_X_POS
         + FILAMENT_CHANGE_X_POS
       #endif
     ;
-    destination[Y_AXIS] = code_seen('Y') ? code_value_linear_units() : 0
+    destination[Y_AXIS] = parser.seen('Y') ? parser.value_linear_units() : 0
       #ifdef FILAMENT_CHANGE_Y_POS
         + FILAMENT_CHANGE_Y_POS
       #endif
@@ -7627,8 +7500,8 @@ inline void gcode_M121() { endstops.enable_globally(false); }
 
     #if HOTENDS > 1 && DISABLED(DUAL_X_CARRIAGE)
       if (active_extruder > 0) {
-        if (!code_seen('X')) destination[X_AXIS] += hotend_offset[X_AXIS][active_extruder];
-        if (!code_seen('Y')) destination[Y_AXIS] += hotend_offset[Y_AXIS][active_extruder];
+        if (!parser.seen('X')) destination[X_AXIS] += hotend_offset[X_AXIS][active_extruder];
+        if (!parser.seen('Y')) destination[Y_AXIS] += hotend_offset[Y_AXIS][active_extruder];
       }
     #endif
 
@@ -7672,11 +7545,11 @@ inline void gcode_M121() { endstops.enable_globally(false); }
    */
   inline void gcode_M150() {
     set_led_color(
-      code_seen('R') ? (code_has_value() ? code_value_byte() : 255) : 0,
-      code_seen('U') ? (code_has_value() ? code_value_byte() : 255) : 0,
-      code_seen('B') ? (code_has_value() ? code_value_byte() : 255) : 0
+      parser.seen('R') ? (parser.has_value() ? parser.value_byte() : 255) : 0,
+      parser.seen('U') ? (parser.has_value() ? parser.value_byte() : 255) : 0,
+      parser.seen('B') ? (parser.has_value() ? parser.value_byte() : 255) : 0
       #if ENABLED(RGBW_LED)
-        , code_seen('W') ? (code_has_value() ? code_value_byte() : 255) : 0
+        , parser.seen('W') ? (parser.has_value() ? parser.value_byte() : 255) : 0
       #endif
     );
   }
@@ -7693,13 +7566,13 @@ inline void gcode_M200() {
 
   if (get_target_extruder_from_command(200)) return;
 
-  if (code_seen('D')) {
+  if (parser.seen('D')) {
     // setting any extruder filament size disables volumetric on the assumption that
     // slicers either generate in extruder values as cubic mm or as as filament feeds
     // for all extruders
-    volumetric_enabled = (code_value_linear_units() != 0.0);
+    volumetric_enabled = (parser.value_linear_units() != 0.0);
     if (volumetric_enabled) {
-      filament_size[target_extruder] = code_value_linear_units();
+      filament_size[target_extruder] = parser.value_linear_units();
       // make sure all extruders have some sane value for the filament size
       for (uint8_t i = 0; i < COUNT(filament_size); i++)
         if (! filament_size[i]) filament_size[i] = DEFAULT_NOMINAL_FILAMENT_DIA;
@@ -7718,9 +7591,9 @@ inline void gcode_M201() {
   GET_TARGET_EXTRUDER(201);
 
   LOOP_XYZE(i) {
-    if (code_seen(axis_codes[i])) {
+    if (parser.seen(axis_codes[i])) {
       const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0);
-      planner.max_acceleration_mm_per_s2[a] = code_value_axis_units((AxisEnum)a);
+      planner.max_acceleration_mm_per_s2[a] = parser.value_axis_units((AxisEnum)a);
     }
   }
   // steps per sq second need to be updated to agree with the units per sq second (as they are what is used in the planner)
@@ -7730,7 +7603,7 @@ inline void gcode_M201() {
 #if 0 // Not used for Sprinter/grbl gen6
   inline void gcode_M202() {
     LOOP_XYZE(i) {
-      if (code_seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = code_value_axis_units((AxisEnum)i) * planner.axis_steps_per_mm[i];
+      if (parser.seen(axis_codes[i])) axis_travel_steps_per_sqr_second[i] = parser.value_axis_units((AxisEnum)i) * planner.axis_steps_per_mm[i];
     }
   }
 #endif
@@ -7746,9 +7619,9 @@ inline void gcode_M203() {
   GET_TARGET_EXTRUDER(203);
 
   LOOP_XYZE(i)
-    if (code_seen(axis_codes[i])) {
+    if (parser.seen(axis_codes[i])) {
       const uint8_t a = i + (i == E_AXIS ? TARGET_EXTRUDER : 0);
-      planner.max_feedrate_mm_s[a] = code_value_axis_units((AxisEnum)a);
+      planner.max_feedrate_mm_s[a] = parser.value_axis_units((AxisEnum)a);
     }
 }
 
@@ -7762,20 +7635,20 @@ inline void gcode_M203() {
  *  Also sets minimum segment time in ms (B20000) to prevent buffer under-runs and M20 minimum feedrate
  */
 inline void gcode_M204() {
-  if (code_seen('S')) {  // Kept for legacy compatibility. Should NOT BE USED for new developments.
-    planner.travel_acceleration = planner.acceleration = code_value_linear_units();
+  if (parser.seen('S')) {  // Kept for legacy compatibility. Should NOT BE USED for new developments.
+    planner.travel_acceleration = planner.acceleration = parser.value_linear_units();
     SERIAL_ECHOLNPAIR("Setting Print and Travel Acceleration: ", planner.acceleration);
   }
-  if (code_seen('P')) {
-    planner.acceleration = code_value_linear_units();
+  if (parser.seen('P')) {
+    planner.acceleration = parser.value_linear_units();
     SERIAL_ECHOLNPAIR("Setting Print Acceleration: ", planner.acceleration);
   }
-  if (code_seen('R')) {
-    planner.retract_acceleration = code_value_linear_units();
+  if (parser.seen('R')) {
+    planner.retract_acceleration = parser.value_linear_units();
     SERIAL_ECHOLNPAIR("Setting Retract Acceleration: ", planner.retract_acceleration);
   }
-  if (code_seen('T')) {
-    planner.travel_acceleration = code_value_linear_units();
+  if (parser.seen('T')) {
+    planner.travel_acceleration = parser.value_linear_units();
     SERIAL_ECHOLNPAIR("Setting Travel Acceleration: ", planner.travel_acceleration);
   }
 }
@@ -7792,13 +7665,13 @@ inline void gcode_M204() {
  *    E = Max E Jerk (units/sec^2)
  */
 inline void gcode_M205() {
-  if (code_seen('S')) planner.min_feedrate_mm_s = code_value_linear_units();
-  if (code_seen('T')) planner.min_travel_feedrate_mm_s = code_value_linear_units();
-  if (code_seen('B')) planner.min_segment_time = code_value_millis();
-  if (code_seen('X')) planner.max_jerk[X_AXIS] = code_value_linear_units();
-  if (code_seen('Y')) planner.max_jerk[Y_AXIS] = code_value_linear_units();
-  if (code_seen('Z')) planner.max_jerk[Z_AXIS] = code_value_linear_units();
-  if (code_seen('E')) planner.max_jerk[E_AXIS] = code_value_linear_units();
+  if (parser.seen('S')) planner.min_feedrate_mm_s = parser.value_linear_units();
+  if (parser.seen('T')) planner.min_travel_feedrate_mm_s = parser.value_linear_units();
+  if (parser.seen('B')) planner.min_segment_time = parser.value_millis();
+  if (parser.seen('X')) planner.max_jerk[X_AXIS] = parser.value_linear_units();
+  if (parser.seen('Y')) planner.max_jerk[Y_AXIS] = parser.value_linear_units();
+  if (parser.seen('Z')) planner.max_jerk[Z_AXIS] = parser.value_linear_units();
+  if (parser.seen('E')) planner.max_jerk[E_AXIS] = parser.value_linear_units();
 }
 
 #if HAS_M206_COMMAND
@@ -7808,12 +7681,12 @@ inline void gcode_M205() {
    */
   inline void gcode_M206() {
     LOOP_XYZ(i)
-      if (code_seen(axis_codes[i]))
-        set_home_offset((AxisEnum)i, code_value_linear_units());
+      if (parser.seen(axis_codes[i]))
+        set_home_offset((AxisEnum)i, parser.value_linear_units());
 
     #if ENABLED(MORGAN_SCARA)
-      if (code_seen('T')) set_home_offset(A_AXIS, code_value_linear_units()); // Theta
-      if (code_seen('P')) set_home_offset(B_AXIS, code_value_linear_units()); // Psi
+      if (parser.seen('T')) set_home_offset(A_AXIS, parser.value_linear_units()); // Theta
+      if (parser.seen('P')) set_home_offset(B_AXIS, parser.value_linear_units()); // Psi
     #endif
 
     SYNC_PLAN_POSITION_KINEMATIC();
@@ -7836,20 +7709,20 @@ inline void gcode_M205() {
    *    Z = Rotate A and B by this angle
    */
   inline void gcode_M665() {
-    if (code_seen('H')) {
-      home_offset[Z_AXIS] = code_value_linear_units() - DELTA_HEIGHT;
-      current_position[Z_AXIS] += code_value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS];
+    if (parser.seen('H')) {
+      home_offset[Z_AXIS] = parser.value_linear_units() - DELTA_HEIGHT;
+      current_position[Z_AXIS] += parser.value_linear_units() - DELTA_HEIGHT - home_offset[Z_AXIS];
       update_software_endstops(Z_AXIS);
     }
-    if (code_seen('L')) delta_diagonal_rod = code_value_linear_units();
-    if (code_seen('R')) delta_radius = code_value_linear_units();
-    if (code_seen('S')) delta_segments_per_second = code_value_float();
-    if (code_seen('B')) delta_calibration_radius = code_value_float();
-    if (code_seen('X')) delta_tower_angle_trim[A_AXIS] = code_value_float();
-    if (code_seen('Y')) delta_tower_angle_trim[B_AXIS] = code_value_float();
-    if (code_seen('Z')) { // rotate all 3 axis for Z = 0
-      delta_tower_angle_trim[A_AXIS] -= code_value_float();
-      delta_tower_angle_trim[B_AXIS] -= code_value_float();
+    if (parser.seen('L')) delta_diagonal_rod = parser.value_linear_units();
+    if (parser.seen('R')) delta_radius = parser.value_linear_units();
+    if (parser.seen('S')) delta_segments_per_second = parser.value_float();
+    if (parser.seen('B')) delta_calibration_radius = parser.value_float();
+    if (parser.seen('X')) delta_tower_angle_trim[A_AXIS] = parser.value_float();
+    if (parser.seen('Y')) delta_tower_angle_trim[B_AXIS] = parser.value_float();
+    if (parser.seen('Z')) { // rotate all 3 axis for Z = 0
+      delta_tower_angle_trim[A_AXIS] -= parser.value_float();
+      delta_tower_angle_trim[B_AXIS] -= parser.value_float();
     }
     recalc_delta_settings(delta_radius, delta_diagonal_rod);
   }
@@ -7863,8 +7736,8 @@ inline void gcode_M205() {
       }
     #endif
     LOOP_XYZ(i) {
-      if (code_seen(axis_codes[i])) {
-        endstop_adj[i] = code_value_linear_units();
+      if (parser.seen(axis_codes[i])) {
+        endstop_adj[i] = parser.value_linear_units();
         #if ENABLED(DEBUG_LEVELING_FEATURE)
           if (DEBUGGING(LEVELING)) {
             SERIAL_ECHOPAIR("endstop_adj[", axis_codes[i]);
@@ -7890,7 +7763,7 @@ inline void gcode_M205() {
    * M666: For Z Dual Endstop setup, set z axis offset to the z2 axis.
    */
   inline void gcode_M666() {
-    if (code_seen('Z')) z_endstop_adj = code_value_linear_units();
+    if (parser.seen('Z')) z_endstop_adj = parser.value_linear_units();
     SERIAL_ECHOLNPAIR("Z Endstop Adjustment set to (mm):", z_endstop_adj);
   }
 
@@ -7907,11 +7780,11 @@ inline void gcode_M205() {
    *   Z[units]     retract_zlift
    */
   inline void gcode_M207() {
-    if (code_seen('S')) retract_length = code_value_axis_units(E_AXIS);
-    if (code_seen('F')) retract_feedrate_mm_s = MMM_TO_MMS(code_value_axis_units(E_AXIS));
-    if (code_seen('Z')) retract_zlift = code_value_linear_units();
+    if (parser.seen('S')) retract_length = parser.value_axis_units(E_AXIS);
+    if (parser.seen('F')) retract_feedrate_mm_s = MMM_TO_MMS(parser.value_axis_units(E_AXIS));
+    if (parser.seen('Z')) retract_zlift = parser.value_linear_units();
     #if EXTRUDERS > 1
-      if (code_seen('W')) retract_length_swap = code_value_axis_units(E_AXIS);
+      if (parser.seen('W')) retract_length_swap = parser.value_axis_units(E_AXIS);
     #endif
   }
 
@@ -7923,10 +7796,10 @@ inline void gcode_M205() {
    *   F[units/min] retract_recover_feedrate_mm_s
    */
   inline void gcode_M208() {
-    if (code_seen('S')) retract_recover_length = code_value_axis_units(E_AXIS);
-    if (code_seen('F')) retract_recover_feedrate_mm_s = MMM_TO_MMS(code_value_axis_units(E_AXIS));
+    if (parser.seen('S')) retract_recover_length = parser.value_axis_units(E_AXIS);
+    if (parser.seen('F')) retract_recover_feedrate_mm_s = MMM_TO_MMS(parser.value_axis_units(E_AXIS));
     #if EXTRUDERS > 1
-      if (code_seen('W')) retract_recover_length_swap = code_value_axis_units(E_AXIS);
+      if (parser.seen('W')) retract_recover_length_swap = parser.value_axis_units(E_AXIS);
     #endif
   }
 
@@ -7936,8 +7809,8 @@ inline void gcode_M205() {
    *   moves will be classified as retraction.
    */
   inline void gcode_M209() {
-    if (code_seen('S')) {
-      autoretract_enabled = code_value_bool();
+    if (parser.seen('S')) {
+      autoretract_enabled = parser.value_bool();
       for (int i = 0; i < EXTRUDERS; i++) retracted[i] = false;
     }
   }
@@ -7952,7 +7825,7 @@ inline void gcode_M205() {
 inline void gcode_M211() {
   SERIAL_ECHO_START;
   #if HAS_SOFTWARE_ENDSTOPS
-    if (code_seen('S')) soft_endstops_enabled = code_value_bool();
+    if (parser.seen('S')) soft_endstops_enabled = parser.value_bool();
     SERIAL_ECHOPGM(MSG_SOFT_ENDSTOPS);
     serialprintPGM(soft_endstops_enabled ? PSTR(MSG_ON) : PSTR(MSG_OFF));
   #else
@@ -7982,11 +7855,11 @@ inline void gcode_M211() {
   inline void gcode_M218() {
     if (get_target_extruder_from_command(218) || target_extruder == 0) return;
 
-    if (code_seen('X')) hotend_offset[X_AXIS][target_extruder] = code_value_linear_units();
-    if (code_seen('Y')) hotend_offset[Y_AXIS][target_extruder] = code_value_linear_units();
+    if (parser.seen('X')) hotend_offset[X_AXIS][target_extruder] = parser.value_linear_units();
+    if (parser.seen('Y')) hotend_offset[Y_AXIS][target_extruder] = parser.value_linear_units();
 
     #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_NOZZLE)
-      if (code_seen('Z')) hotend_offset[Z_AXIS][target_extruder] = code_value_linear_units();
+      if (parser.seen('Z')) hotend_offset[Z_AXIS][target_extruder] = parser.value_linear_units();
     #endif
 
     SERIAL_ECHO_START;
@@ -8010,7 +7883,7 @@ inline void gcode_M211() {
  * M220: Set speed percentage factor, aka "Feed Rate" (M220 S95)
  */
 inline void gcode_M220() {
-  if (code_seen('S')) feedrate_percentage = code_value_int();
+  if (parser.seen('S')) feedrate_percentage = parser.value_int();
 }
 
 /**
@@ -8018,17 +7891,17 @@ inline void gcode_M220() {
  */
 inline void gcode_M221() {
   if (get_target_extruder_from_command(221)) return;
-  if (code_seen('S'))
-    flow_percentage[target_extruder] = code_value_int();
+  if (parser.seen('S'))
+    flow_percentage[target_extruder] = parser.value_int();
 }
 
 /**
  * M226: Wait until the specified pin reaches the state required (M226 P<pin> S<state>)
  */
 inline void gcode_M226() {
-  if (code_seen('P')) {
-    int pin_number = code_value_int(),
-        pin_state = code_seen('S') ? code_value_int() : -1; // required pin state - default is inverted
+  if (parser.seen('P')) {
+    int pin_number = parser.value_int(),
+        pin_state = parser.seen('S') ? parser.value_int() : -1; // required pin state - default is inverted
 
     if (pin_state >= -1 && pin_state <= 1 && pin_number > -1 && !pin_is_protected(pin_number)) {
 
@@ -8052,7 +7925,7 @@ inline void gcode_M226() {
       while (digitalRead(pin_number) != target) idle();
 
     } // pin_state -1 0 1 && pin_number > -1
-  } // code_seen('P')
+  } // parser.seen('P')
 }
 
 #if ENABLED(EXPERIMENTAL_I2CBUS)
@@ -8075,16 +7948,16 @@ inline void gcode_M226() {
    */
   inline void gcode_M260() {
     // Set the target address
-    if (code_seen('A')) i2c.address(code_value_byte());
+    if (parser.seen('A')) i2c.address(parser.value_byte());
 
     // Add a new byte to the buffer
-    if (code_seen('B')) i2c.addbyte(code_value_byte());
+    if (parser.seen('B')) i2c.addbyte(parser.value_byte());
 
     // Flush the buffer to the bus
-    if (code_seen('S')) i2c.send();
+    if (parser.seen('S')) i2c.send();
 
     // Reset and rewind the buffer
-    else if (code_seen('R')) i2c.reset();
+    else if (parser.seen('R')) i2c.reset();
   }
 
   /**
@@ -8093,9 +7966,9 @@ inline void gcode_M226() {
    * Usage: M261 A<slave device address base 10> B<number of bytes>
    */
   inline void gcode_M261() {
-    if (code_seen('A')) i2c.address(code_value_byte());
+    if (parser.seen('A')) i2c.address(parser.value_byte());
 
-    uint8_t bytes = code_seen('B') ? code_value_byte() : 1;
+    uint8_t bytes = parser.seen('B') ? parser.value_byte() : 1;
 
     if (i2c.addr && bytes && bytes <= TWIBUS_BUFFER_SIZE) {
       i2c.relay(bytes);
@@ -8114,11 +7987,11 @@ inline void gcode_M226() {
    * M280: Get or set servo position. P<index> [S<angle>]
    */
   inline void gcode_M280() {
-    if (!code_seen('P')) return;
-    int servo_index = code_value_int();
+    if (!parser.seen('P')) return;
+    int servo_index = parser.value_int();
     if (WITHIN(servo_index, 0, NUM_SERVOS - 1)) {
-      if (code_seen('S'))
-        MOVE_SERVO(servo_index, code_value_int());
+      if (parser.seen('S'))
+        MOVE_SERVO(servo_index, parser.value_int());
       else {
         SERIAL_ECHO_START;
         SERIAL_ECHOPAIR(" Servo ", servo_index);
@@ -8140,8 +8013,8 @@ inline void gcode_M226() {
    * M300: Play beep sound S<frequency Hz> P<duration ms>
    */
   inline void gcode_M300() {
-    uint16_t const frequency = code_seen('S') ? code_value_ushort() : 260;
-    uint16_t duration = code_seen('P') ? code_value_ushort() : 1000;
+    uint16_t const frequency = parser.seen('S') ? parser.value_ushort() : 260;
+    uint16_t duration = parser.seen('P') ? parser.value_ushort() : 1000;
 
     // Limits the tone duration to 0-5 seconds.
     NOMORE(duration, 5000);
@@ -8169,15 +8042,15 @@ inline void gcode_M226() {
 
     // multi-extruder PID patch: M301 updates or prints a single extruder's PID values
     // default behaviour (omitting E parameter) is to update for extruder 0 only
-    int e = code_seen('E') ? code_value_int() : 0; // extruder being updated
+    int e = parser.seen('E') ? parser.value_int() : 0; // extruder being updated
 
     if (e < HOTENDS) { // catch bad input value
-      if (code_seen('P')) PID_PARAM(Kp, e) = code_value_float();
-      if (code_seen('I')) PID_PARAM(Ki, e) = scalePID_i(code_value_float());
-      if (code_seen('D')) PID_PARAM(Kd, e) = scalePID_d(code_value_float());
+      if (parser.seen('P')) PID_PARAM(Kp, e) = parser.value_float();
+      if (parser.seen('I')) PID_PARAM(Ki, e) = scalePID_i(parser.value_float());
+      if (parser.seen('D')) PID_PARAM(Kd, e) = scalePID_d(parser.value_float());
       #if ENABLED(PID_EXTRUSION_SCALING)
-        if (code_seen('C')) PID_PARAM(Kc, e) = code_value_float();
-        if (code_seen('L')) lpq_len = code_value_float();
+        if (parser.seen('C')) PID_PARAM(Kc, e) = parser.value_float();
+        if (parser.seen('L')) lpq_len = parser.value_float();
         NOMORE(lpq_len, LPQ_MAX_LEN);
       #endif
 
@@ -8206,9 +8079,9 @@ inline void gcode_M226() {
 #if ENABLED(PIDTEMPBED)
 
   inline void gcode_M304() {
-    if (code_seen('P')) thermalManager.bedKp = code_value_float();
-    if (code_seen('I')) thermalManager.bedKi = scalePID_i(code_value_float());
-    if (code_seen('D')) thermalManager.bedKd = scalePID_d(code_value_float());
+    if (parser.seen('P')) thermalManager.bedKp = parser.value_float();
+    if (parser.seen('I')) thermalManager.bedKi = scalePID_i(parser.value_float());
+    if (parser.seen('D')) thermalManager.bedKd = scalePID_d(parser.value_float());
 
     thermalManager.updatePID();
 
@@ -8262,7 +8135,7 @@ inline void gcode_M226() {
    * M250: Read and optionally set the LCD contrast
    */
   inline void gcode_M250() {
-    if (code_seen('C')) set_lcd_contrast(code_value_int());
+    if (parser.seen('C')) set_lcd_contrast(parser.value_int());
     SERIAL_PROTOCOLPGM("lcd contrast value: ");
     SERIAL_PROTOCOL(lcd_contrast);
     SERIAL_EOL;
@@ -8288,14 +8161,14 @@ inline void gcode_M226() {
    *       M302 S170 P1 ; set min extrude temp to 170 but leave disabled
    */
   inline void gcode_M302() {
-    bool seen_S = code_seen('S');
+    bool seen_S = parser.seen('S');
     if (seen_S) {
-      thermalManager.extrude_min_temp = code_value_temp_abs();
+      thermalManager.extrude_min_temp = parser.value_celsius();
       thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0);
     }
 
-    if (code_seen('P'))
-      thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || code_value_bool();
+    if (parser.seen('P'))
+      thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || parser.value_bool();
     else if (!seen_S) {
       // Report current state
       SERIAL_ECHO_START;
@@ -8317,11 +8190,11 @@ inline void gcode_M226() {
  */
 inline void gcode_M303() {
   #if HAS_PID_HEATING
-    const int e = code_seen('E') ? code_value_int() : 0,
-              c = code_seen('C') ? code_value_int() : 5;
-    const bool u = code_seen('U') && code_value_bool();
+    const int e = parser.seen('E') ? parser.value_int() : 0,
+              c = parser.seen('C') ? parser.value_int() : 5;
+    const bool u = parser.seen('U') && parser.value_bool();
 
-    int16_t temp = code_seen('S') ? code_value_temp_abs() : (e < 0 ? 70 : 150);
+    int16_t temp = parser.seen('S') ? parser.value_celsius() : (e < 0 ? 70 : 150);
 
     if (WITHIN(e, 0, HOTENDS - 1))
       target_extruder = e;
@@ -8482,8 +8355,8 @@ inline void gcode_M400() { stepper.synchronize(); }
    * M404: Display or set (in current units) the nominal filament width (3mm, 1.75mm ) W<3.0>
    */
   inline void gcode_M404() {
-    if (code_seen('W')) {
-      filament_width_nominal = code_value_linear_units();
+    if (parser.seen('W')) {
+      filament_width_nominal = parser.value_linear_units();
     }
     else {
       SERIAL_PROTOCOLPGM("Filament dia (nominal mm):");
@@ -8496,8 +8369,8 @@ inline void gcode_M400() { stepper.synchronize(); }
    */
   inline void gcode_M405() {
     // This is technically a linear measurement, but since it's quantized to centimeters and is a different unit than
-    // everything else, it uses code_value_int() instead of code_value_linear_units().
-    if (code_seen('D')) meas_delay_cm = code_value_int();
+    // everything else, it uses parser.value_int() instead of parser.value_linear_units().
+    if (parser.seen('D')) meas_delay_cm = parser.value_int();
     NOMORE(meas_delay_cm, MAX_MEASUREMENT_DELAY);
 
     if (filwidth_delay_index[1] == -1) { // Initialize the ring buffer if not done since startup
@@ -8555,8 +8428,8 @@ void quickstop_stepper() {
 
     #if ENABLED(AUTO_BED_LEVELING_UBL)
       // L to load a mesh from the EEPROM
-      if (code_seen('L')) {
-        const int8_t storage_slot = code_has_value() ? code_value_int() : ubl.state.storage_slot;
+      if (parser.seen('L')) {
+        const int8_t storage_slot = parser.has_value() ? parser.value_int() : ubl.state.storage_slot;
         const int16_t a = settings.calc_num_meshes();
 
         if (!a) {
@@ -8576,7 +8449,7 @@ void quickstop_stepper() {
     #endif // AUTO_BED_LEVELING_UBL
 
     // V to print the matrix or mesh
-    if (code_seen('V')) {
+    if (parser.seen('V')) {
       #if ABL_PLANAR
         planner.bed_level_matrix.debug(PSTR("Bed Level Correction Matrix:"));
       #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
@@ -8596,7 +8469,7 @@ void quickstop_stepper() {
 
     #if ENABLED(AUTO_BED_LEVELING_UBL)
       // L to load a mesh from the EEPROM
-      if (code_seen('L') || code_seen('V')) {
+      if (parser.seen('L') || parser.seen('V')) {
         ubl.display_map(0);  // Currently only supports one map type
         SERIAL_ECHOLNPAIR("UBL_MESH_VALID = ", UBL_MESH_VALID);
         SERIAL_ECHOLNPAIR("ubl.state.storage_slot = ", ubl.state.storage_slot);
@@ -8604,13 +8477,13 @@ void quickstop_stepper() {
     #endif
 
     bool to_enable = false;
-    if (code_seen('S')) {
-      to_enable = code_value_bool();
+    if (parser.seen('S')) {
+      to_enable = parser.value_bool();
       set_bed_leveling_enabled(to_enable);
     }
 
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-      if (code_seen('Z')) set_z_fade_height(code_value_linear_units());
+      if (parser.seen('Z')) set_z_fade_height(parser.value_linear_units());
     #endif
 
     const bool new_status =
@@ -8645,11 +8518,11 @@ void quickstop_stepper() {
    *   M421 I<xindex> J<yindex> Q<offset>
    */
   inline void gcode_M421() {
-    const bool hasX = code_seen('X'), hasI = code_seen('I');
-    const int8_t ix = hasI ? code_value_int() : hasX ? mbl.probe_index_x(RAW_X_POSITION(code_value_linear_units())) : -1;
-    const bool hasY = code_seen('Y'), hasJ = code_seen('J');
-    const int8_t iy = hasJ ? code_value_int() : hasY ? mbl.probe_index_y(RAW_Y_POSITION(code_value_linear_units())) : -1;
-    const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
+    const bool hasX = parser.seen('X'), hasI = parser.seen('I');
+    const int8_t ix = hasI ? parser.value_int() : hasX ? mbl.probe_index_x(RAW_X_POSITION(parser.value_linear_units())) : -1;
+    const bool hasY = parser.seen('Y'), hasJ = parser.seen('J');
+    const int8_t iy = hasJ ? parser.value_int() : hasY ? mbl.probe_index_y(RAW_Y_POSITION(parser.value_linear_units())) : -1;
+    const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q');
 
     if (int(hasI && hasJ) + int(hasX && hasY) != 1 || !(hasZ || hasQ)) {
       SERIAL_ERROR_START;
@@ -8660,7 +8533,7 @@ void quickstop_stepper() {
       SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
     }
     else
-      mbl.set_z(ix, iy, code_value_linear_units() + (hasQ ? mbl.z_values[ix][iy] : 0));
+      mbl.set_z(ix, iy, parser.value_linear_units() + (hasQ ? mbl.z_values[ix][iy] : 0));
   }
 
 #elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
@@ -8673,11 +8546,11 @@ void quickstop_stepper() {
    *   M421 I<xindex> J<yindex> Q<offset>
    */
   inline void gcode_M421() {
-    const bool hasI = code_seen('I');
-    const int8_t ix = hasI ? code_value_int() : -1;
-    const bool hasJ = code_seen('J');
-    const int8_t iy = hasJ ? code_value_int() : -1;
-    const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
+    const bool hasI = parser.seen('I');
+    const int8_t ix = hasI ? parser.value_int() : -1;
+    const bool hasJ = parser.seen('J');
+    const int8_t iy = hasJ ? parser.value_int() : -1;
+    const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q');
 
     if (!hasI || !hasJ || !(hasZ || hasQ)) {
       SERIAL_ERROR_START;
@@ -8688,7 +8561,7 @@ void quickstop_stepper() {
       SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
     }
     else {
-      z_values[ix][iy] = code_value_linear_units() + (hasQ ? z_values[ix][iy] : 0);
+      z_values[ix][iy] = parser.value_linear_units() + (hasQ ? z_values[ix][iy] : 0);
       #if ENABLED(ABL_BILINEAR_SUBDIVISION)
         bed_level_virt_interpolate();
       #endif
@@ -8707,12 +8580,11 @@ void quickstop_stepper() {
    *   M421 C Q<offset>
    */
   inline void gcode_M421() {
-    const bool hasC = code_seen('C');
-    const bool hasI = code_seen('I');
-    int8_t ix = hasI ? code_value_int() : -1;
-    const bool hasJ = code_seen('J');
-    int8_t iy = hasJ ? code_value_int() : -1;
-    const bool hasZ = code_seen('Z'), hasQ = !hasZ && code_seen('Q');
+    const bool hasC = parser.seen('C'), hasI = parser.seen('I');
+    int8_t ix = hasI ? parser.value_int() : -1;
+    const bool hasJ = parser.seen('J');
+    int8_t iy = hasJ ? parser.value_int() : -1;
+    const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q');
 
     if (hasC) {
       const mesh_index_pair location = ubl.find_closest_mesh_point_of_type(REAL, current_position[X_AXIS], current_position[Y_AXIS], USE_NOZZLE_AS_REFERENCE, NULL, false);
@@ -8729,7 +8601,7 @@ void quickstop_stepper() {
       SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
     }
     else
-      ubl.z_values[ix][iy] = code_value_linear_units() + (hasQ ? ubl.z_values[ix][iy] : 0);
+      ubl.z_values[ix][iy] = parser.value_linear_units() + (hasQ ? ubl.z_values[ix][iy] : 0);
   }
 
 #endif // AUTO_BED_LEVELING_UBL
@@ -8803,7 +8675,7 @@ inline void gcode_M502() {
  * M503: print settings currently in memory
  */
 inline void gcode_M503() {
-  (void)settings.report(code_seen('S') && !code_value_bool());
+  (void)settings.report(parser.seen('S') && !parser.value_bool());
 }
 
 #if ENABLED(ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED)
@@ -8812,7 +8684,7 @@ inline void gcode_M503() {
    * M540: Set whether SD card print should abort on endstop hit (M540 S<0|1>)
    */
   inline void gcode_M540() {
-    if (code_seen('S')) stepper.abort_on_endstop_hit = code_value_bool();
+    if (parser.seen('S')) stepper.abort_on_endstop_hit = parser.value_bool();
   }
 
 #endif // ABORT_ON_ENDSTOP_HIT_FEATURE_ENABLED
@@ -8858,8 +8730,8 @@ inline void gcode_M503() {
   inline void gcode_M851() {
     SERIAL_ECHO_START;
     SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET " ");
-    if (code_seen('Z')) {
-      const float value = code_value_linear_units();
+    if (parser.seen('Z')) {
+      const float value = parser.value_linear_units();
       if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX)) {
         zprobe_zoffset = value;
         refresh_zprobe_zoffset();
@@ -8933,7 +8805,7 @@ inline void gcode_M503() {
     set_destination_to_current();
 
     // Initial retract before move to filament change position
-    destination[E_AXIS] += code_seen('E') ? code_value_axis_units(E_AXIS) : 0
+    destination[E_AXIS] += parser.seen('E') ? parser.value_axis_units(E_AXIS) : 0
       #if defined(FILAMENT_CHANGE_RETRACT_LENGTH) && FILAMENT_CHANGE_RETRACT_LENGTH > 0
         - (FILAMENT_CHANGE_RETRACT_LENGTH)
       #endif
@@ -8942,7 +8814,7 @@ inline void gcode_M503() {
     RUNPLAN(FILAMENT_CHANGE_RETRACT_FEEDRATE);
 
     // Lift Z axis
-    float z_lift = code_seen('Z') ? code_value_linear_units() :
+    float z_lift = parser.seen('Z') ? parser.value_linear_units() :
       #if defined(FILAMENT_CHANGE_Z_ADD) && FILAMENT_CHANGE_Z_ADD > 0
         FILAMENT_CHANGE_Z_ADD
       #else
@@ -8957,12 +8829,12 @@ inline void gcode_M503() {
     }
 
     // Move XY axes to filament exchange position
-    if (code_seen('X')) destination[X_AXIS] = code_value_linear_units();
+    if (parser.seen('X')) destination[X_AXIS] = parser.value_linear_units();
     #ifdef FILAMENT_CHANGE_X_POS
       else destination[X_AXIS] = FILAMENT_CHANGE_X_POS;
     #endif
 
-    if (code_seen('Y')) destination[Y_AXIS] = code_value_linear_units();
+    if (parser.seen('Y')) destination[Y_AXIS] = parser.value_linear_units();
     #ifdef FILAMENT_CHANGE_Y_POS
       else destination[Y_AXIS] = FILAMENT_CHANGE_Y_POS;
     #endif
@@ -8974,7 +8846,7 @@ inline void gcode_M503() {
     idle();
 
     // Unload filament
-    destination[E_AXIS] += code_seen('L') ? code_value_axis_units(E_AXIS) : 0
+    destination[E_AXIS] += parser.seen('L') ? parser.value_axis_units(E_AXIS) : 0
       #if FILAMENT_CHANGE_UNLOAD_LENGTH > 0
         - (FILAMENT_CHANGE_UNLOAD_LENGTH)
       #endif
@@ -9062,7 +8934,7 @@ inline void gcode_M503() {
     lcd_filament_change_show_message(FILAMENT_CHANGE_MESSAGE_LOAD);
 
     // Load filament
-    destination[E_AXIS] += code_seen('L') ? -code_value_axis_units(E_AXIS) : 0
+    destination[E_AXIS] += parser.seen('L') ? -parser.value_axis_units(E_AXIS) : 0
       #if FILAMENT_CHANGE_LOAD_LENGTH > 0
         + FILAMENT_CHANGE_LOAD_LENGTH
       #endif
@@ -9145,14 +9017,14 @@ inline void gcode_M503() {
    */
   inline void gcode_M605() {
     stepper.synchronize();
-    if (code_seen('S')) dual_x_carriage_mode = (DualXMode)code_value_byte();
+    if (parser.seen('S')) dual_x_carriage_mode = (DualXMode)parser.value_byte();
     switch (dual_x_carriage_mode) {
       case DXC_FULL_CONTROL_MODE:
       case DXC_AUTO_PARK_MODE:
         break;
       case DXC_DUPLICATION_MODE:
-        if (code_seen('X')) duplicate_extruder_x_offset = max(code_value_linear_units(), X2_MIN_POS - x_home_pos(0));
-        if (code_seen('R')) duplicate_extruder_temp_offset = code_value_temp_diff();
+        if (parser.seen('X')) duplicate_extruder_x_offset = max(parser.value_linear_units(), X2_MIN_POS - x_home_pos(0));
+        if (parser.seen('R')) duplicate_extruder_temp_offset = parser.value_celsius_diff();
         SERIAL_ECHO_START;
         SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
         SERIAL_CHAR(' ');
@@ -9177,7 +9049,7 @@ inline void gcode_M503() {
 
   inline void gcode_M605() {
     stepper.synchronize();
-    extruder_duplication_enabled = code_seen('S') && code_value_int() == (int)DXC_DUPLICATION_MODE;
+    extruder_duplication_enabled = parser.seen('S') && parser.value_int() == (int)DXC_DUPLICATION_MODE;
     SERIAL_ECHO_START;
     SERIAL_ECHOLNPAIR(MSG_DUPLICATION_MODE, extruder_duplication_enabled ? MSG_ON : MSG_OFF);
   }
@@ -9195,14 +9067,14 @@ inline void gcode_M503() {
   inline void gcode_M900() {
     stepper.synchronize();
 
-    const float newK = code_seen('K') ? code_value_float() : -1;
+    const float newK = parser.seen('K') ? parser.value_float() : -1;
     if (newK >= 0) planner.extruder_advance_k = newK;
 
-    float newR = code_seen('R') ? code_value_float() : -1;
+    float newR = parser.seen('R') ? parser.value_float() : -1;
     if (newR < 0) {
-      const float newD = code_seen('D') ? code_value_float() : -1,
-                  newW = code_seen('W') ? code_value_float() : -1,
-                  newH = code_seen('H') ? code_value_float() : -1;
+      const float newD = parser.seen('D') ? parser.value_float() : -1,
+                  newW = parser.seen('W') ? parser.value_float() : -1,
+                  newH = parser.seen('H') ? parser.value_float() : -1;
       if (newD >= 0 && newW >= 0 && newH >= 0)
         newR = newD ? (newW * newH) / (sq(newD * 0.5) * M_PI) : 0;
     }
@@ -9271,7 +9143,7 @@ inline void gcode_M503() {
   inline void gcode_M906() {
     uint16_t values[XYZE];
     LOOP_XYZE(i)
-      values[i] = code_seen(axis_codes[i]) ? code_value_int() : 0;
+      values[i] = parser.seen(axis_codes[i]) ? parser.value_int() : 0;
 
     #if ENABLED(X_IS_TMC2130)
       if (values[X_AXIS]) tmc2130_set_current(stepperX, 'X', values[X_AXIS]);
@@ -9291,7 +9163,7 @@ inline void gcode_M503() {
     #endif
 
     #if ENABLED(AUTOMATIC_CURRENT_CONTROL)
-      if (code_seen('S')) auto_current_control = code_value_bool();
+      if (parser.seen('S')) auto_current_control = parser.value_bool();
     #endif
   }
 
@@ -9300,7 +9172,7 @@ inline void gcode_M503() {
    * The flag is held by the library and persist until manually cleared by M912
    */
   inline void gcode_M911() {
-    const bool reportX = code_seen('X'), reportY = code_seen('Y'), reportZ = code_seen('Z'), reportE = code_seen('E'),
+    const bool reportX = parser.seen('X'), reportY = parser.seen('Y'), reportZ = parser.seen('Z'), reportE = parser.seen('E'),
              reportAll = (!reportX && !reportY && !reportZ && !reportE) || (reportX && reportY && reportZ && reportE);
     #if ENABLED(X_IS_TMC2130)
       if (reportX || reportAll) tmc2130_report_otpw(stepperX, 'X');
@@ -9320,7 +9192,7 @@ inline void gcode_M503() {
    * M912: Clear TMC2130 stepper driver overtemperature pre-warn flag held by the library
    */
   inline void gcode_M912() {
-    const bool clearX = code_seen('X'), clearY = code_seen('Y'), clearZ = code_seen('Z'), clearE = code_seen('E'),
+    const bool clearX = parser.seen('X'), clearY = parser.seen('Y'), clearZ = parser.seen('Z'), clearE = parser.seen('E'),
              clearAll = (!clearX && !clearY && !clearZ && !clearE) || (clearX && clearY && clearZ && clearE);
     #if ENABLED(X_IS_TMC2130)
       if (clearX || clearAll) tmc2130_clear_otpw(stepperX, 'X');
@@ -9343,7 +9215,7 @@ inline void gcode_M503() {
     inline void gcode_M913() {
       uint16_t values[XYZE];
       LOOP_XYZE(i)
-        values[i] = code_seen(axis_codes[i]) ? code_value_int() : 0;
+        values[i] = parser.seen(axis_codes[i]) ? parser.value_int() : 0;
 
       #if ENABLED(X_IS_TMC2130)
         if (values[X_AXIS]) tmc2130_set_pwmthrs(stepperX, 'X', values[X_AXIS], planner.axis_steps_per_mm[X_AXIS]);
@@ -9370,11 +9242,11 @@ inline void gcode_M503() {
   #if ENABLED(SENSORLESS_HOMING)
     inline void gcode_M914() {
       #if ENABLED(X_IS_TMC2130)
-        if (code_seen(axis_codes[X_AXIS])) tmc2130_set_sgt(stepperX, 'X', code_value_int());
+        if (parser.seen(axis_codes[X_AXIS])) tmc2130_set_sgt(stepperX, 'X', parser.value_int());
         else tmc2130_get_sgt(stepperX, 'X');
       #endif
       #if ENABLED(Y_IS_TMC2130)
-        if (code_seen(axis_codes[Y_AXIS])) tmc2130_set_sgt(stepperY, 'Y', code_value_int());
+        if (parser.seen(axis_codes[Y_AXIS])) tmc2130_set_sgt(stepperY, 'Y', parser.value_int());
         else tmc2130_get_sgt(stepperY, 'Y');
       #endif
     }
@@ -9387,32 +9259,32 @@ inline void gcode_M503() {
  */
 inline void gcode_M907() {
   #if HAS_DIGIPOTSS
-    LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.digipot_current(i, code_value_int());
-    if (code_seen('B')) stepper.digipot_current(4, code_value_int());
-    if (code_seen('S')) for (uint8_t i = 0; i <= 4; i++) stepper.digipot_current(i, code_value_int());
+    LOOP_XYZE(i) if (parser.seen(axis_codes[i])) stepper.digipot_current(i, parser.value_int());
+    if (parser.seen('B')) stepper.digipot_current(4, parser.value_int());
+    if (parser.seen('S')) for (uint8_t i = 0; i <= 4; i++) stepper.digipot_current(i, parser.value_int());
   #elif HAS_MOTOR_CURRENT_PWM
     #if PIN_EXISTS(MOTOR_CURRENT_PWM_XY)
-      if (code_seen('X')) stepper.digipot_current(0, code_value_int());
+      if (parser.seen('X')) stepper.digipot_current(0, parser.value_int());
     #endif
     #if PIN_EXISTS(MOTOR_CURRENT_PWM_Z)
-      if (code_seen('Z')) stepper.digipot_current(1, code_value_int());
+      if (parser.seen('Z')) stepper.digipot_current(1, parser.value_int());
     #endif
     #if PIN_EXISTS(MOTOR_CURRENT_PWM_E)
-      if (code_seen('E')) stepper.digipot_current(2, code_value_int());
+      if (parser.seen('E')) stepper.digipot_current(2, parser.value_int());
     #endif
   #endif
   #if ENABLED(DIGIPOT_I2C)
     // this one uses actual amps in floating point
-    LOOP_XYZE(i) if (code_seen(axis_codes[i])) digipot_i2c_set_current(i, code_value_float());
+    LOOP_XYZE(i) if (parser.seen(axis_codes[i])) digipot_i2c_set_current(i, parser.value_float());
     // for each additional extruder (named B,C,D,E..., channels 4,5,6,7...)
-    for (uint8_t i = NUM_AXIS; i < DIGIPOT_I2C_NUM_CHANNELS; i++) if (code_seen('B' + i - (NUM_AXIS))) digipot_i2c_set_current(i, code_value_float());
+    for (uint8_t i = NUM_AXIS; i < DIGIPOT_I2C_NUM_CHANNELS; i++) if (parser.seen('B' + i - (NUM_AXIS))) digipot_i2c_set_current(i, parser.value_float());
   #endif
   #if ENABLED(DAC_STEPPER_CURRENT)
-    if (code_seen('S')) {
-      const float dac_percent = code_value_float();
+    if (parser.seen('S')) {
+      const float dac_percent = parser.value_float();
       for (uint8_t i = 0; i <= 4; i++) dac_current_percent(i, dac_percent);
     }
-    LOOP_XYZE(i) if (code_seen(axis_codes[i])) dac_current_percent(i, code_value_float());
+    LOOP_XYZE(i) if (parser.seen(axis_codes[i])) dac_current_percent(i, parser.value_float());
   #endif
 }
 
@@ -9424,14 +9296,14 @@ inline void gcode_M907() {
   inline void gcode_M908() {
     #if HAS_DIGIPOTSS
       stepper.digitalPotWrite(
-        code_seen('P') ? code_value_int() : 0,
-        code_seen('S') ? code_value_int() : 0
+        parser.seen('P') ? parser.value_int() : 0,
+        parser.seen('S') ? parser.value_int() : 0
       );
     #endif
     #ifdef DAC_STEPPER_CURRENT
       dac_current_raw(
-        code_seen('P') ? code_value_byte() : -1,
-        code_seen('S') ? code_value_ushort() : 0
+        parser.seen('P') ? parser.value_byte() : -1,
+        parser.seen('S') ? parser.value_ushort() : 0
       );
     #endif
   }
@@ -9450,9 +9322,9 @@ inline void gcode_M907() {
 
   // M350 Set microstepping mode. Warning: Steps per unit remains unchanged. S code sets stepping mode for all drivers.
   inline void gcode_M350() {
-    if (code_seen('S')) for (int i = 0; i <= 4; i++) stepper.microstep_mode(i, code_value_byte());
-    LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_mode(i, code_value_byte());
-    if (code_seen('B')) stepper.microstep_mode(4, code_value_byte());
+    if (parser.seen('S')) for (int i = 0; i <= 4; i++) stepper.microstep_mode(i, parser.value_byte());
+    LOOP_XYZE(i) if (parser.seen(axis_codes[i])) stepper.microstep_mode(i, parser.value_byte());
+    if (parser.seen('B')) stepper.microstep_mode(4, parser.value_byte());
     stepper.microstep_readings();
   }
 
@@ -9461,14 +9333,14 @@ inline void gcode_M907() {
    *       S# determines MS1 or MS2, X# sets the pin high/low.
    */
   inline void gcode_M351() {
-    if (code_seen('S')) switch (code_value_byte()) {
+    if (parser.seen('S')) switch (parser.value_byte()) {
       case 1:
-        LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_ms(i, code_value_byte(), -1);
-        if (code_seen('B')) stepper.microstep_ms(4, code_value_byte(), -1);
+        LOOP_XYZE(i) if (parser.seen(axis_codes[i])) stepper.microstep_ms(i, parser.value_byte(), -1);
+        if (parser.seen('B')) stepper.microstep_ms(4, parser.value_byte(), -1);
         break;
       case 2:
-        LOOP_XYZE(i) if (code_seen(axis_codes[i])) stepper.microstep_ms(i, -1, code_value_byte());
-        if (code_seen('B')) stepper.microstep_ms(4, -1, code_value_byte());
+        LOOP_XYZE(i) if (parser.seen(axis_codes[i])) stepper.microstep_ms(i, -1, parser.value_byte());
+        if (parser.seen('B')) stepper.microstep_ms(4, -1, parser.value_byte());
         break;
     }
     stepper.microstep_readings();
@@ -9495,8 +9367,8 @@ inline void gcode_M907() {
  */
 inline void gcode_M355() {
   #if HAS_CASE_LIGHT
-    if (code_seen('P')) case_light_brightness = code_value_byte();
-    if (code_seen('S')) case_light_on = code_value_bool();
+    if (parser.seen('P')) case_light_brightness = parser.value_byte();
+    if (parser.seen('S')) case_light_on = parser.value_bool();
     update_case_light();
     SERIAL_ECHO_START;
     SERIAL_ECHOPGM("Case lights ");
@@ -9518,9 +9390,9 @@ inline void gcode_M355() {
    *
    */
   inline void gcode_M163() {
-    const int mix_index = code_seen('S') ? code_value_int() : 0;
+    const int mix_index = parser.seen('S') ? parser.value_int() : 0;
     if (mix_index < MIXING_STEPPERS) {
-      float mix_value = code_seen('P') ? code_value_float() : 0.0;
+      float mix_value = parser.seen('P') ? parser.value_float() : 0.0;
       NOLESS(mix_value, 0.0);
       mixing_factor[mix_index] = RECIPROCAL(mix_value);
     }
@@ -9535,7 +9407,7 @@ inline void gcode_M355() {
      *
      */
     inline void gcode_M164() {
-      const int tool_index = code_seen('S') ? code_value_int() : 0;
+      const int tool_index = parser.seen('S') ? parser.value_int() : 0;
       if (tool_index < MIXING_VIRTUAL_TOOLS) {
         normalize_mix();
         for (uint8_t i = 0; i < MIXING_STEPPERS; i++)
@@ -9578,7 +9450,7 @@ inline void gcode_M999() {
   Running = true;
   lcd_reset_alert_level();
 
-  if (code_seen('S') && code_value_bool()) return;
+  if (parser.seen('S') && parser.value_bool()) return;
 
   // gcode_LastN = Stopped_gcode_LastN;
   FlushSerialRequestResend();
@@ -9953,8 +9825,8 @@ inline void gcode_T(uint8_t tmp_extruder) {
 
     tool_change(
       tmp_extruder,
-      code_seen('F') ? MMM_TO_MMS(code_value_linear_units()) : 0.0,
-      (tmp_extruder == active_extruder) || (code_seen('S') && code_value_bool())
+      parser.seen('F') ? MMM_TO_MMS(parser.value_linear_units()) : 0.0,
+      (tmp_extruder == active_extruder) || (parser.seen('S') && parser.value_bool())
     );
 
   #endif
@@ -9972,7 +9844,7 @@ inline void gcode_T(uint8_t tmp_extruder) {
  * This is called from the main loop()
  */
 void process_next_command() {
-  current_command = command_queue[cmd_queue_index_r];
+  char * const current_command = command_queue[cmd_queue_index_r];
 
   if (DEBUGGING(ECHO)) {
     SERIAL_ECHO_START;
@@ -9983,70 +9855,20 @@ void process_next_command() {
     #endif
   }
 
-  // Sanitize the current command:
-  //  - Skip leading spaces
-  //  - Bypass N[-0-9][0-9]*[ ]*
-  //  - Overwrite * with nul to mark the end
-  while (*current_command == ' ') ++current_command;
-  if (*current_command == 'N' && NUMERIC_SIGNED(current_command[1])) {
-    current_command += 2; // skip N[-0-9]
-    while (NUMERIC(*current_command)) ++current_command; // skip [0-9]*
-    while (*current_command == ' ') ++current_command; // skip [ ]*
-  }
-  char* starpos = strchr(current_command, '*');  // * should always be the last parameter
-  if (starpos) while (*starpos == ' ' || *starpos == '*') *starpos-- = '\0'; // nullify '*' and ' '
-
-  char *cmd_ptr = current_command;
-
-  // Get the command code, which must be G, M, or T
-  char command_code = *cmd_ptr++;
-
-  // Skip spaces to get the numeric part
-  while (*cmd_ptr == ' ') cmd_ptr++;
-
-  // Allow for decimal point in command
-  #if ENABLED(G38_PROBE_TARGET)
-    uint8_t subcode = 0;
-  #endif
-
-  uint16_t codenum = 0; // define ahead of goto
-
-  // Bail early if there's no code
-  bool code_is_good = NUMERIC(*cmd_ptr);
-  if (!code_is_good) goto ExitUnknownCommand;
-
-  // Get and skip the code number
-  do {
-    codenum = (codenum * 10) + (*cmd_ptr - '0');
-    cmd_ptr++;
-  } while (NUMERIC(*cmd_ptr));
-
-  // Allow for decimal point in command
-  #if ENABLED(G38_PROBE_TARGET)
-    if (*cmd_ptr == '.') {
-      cmd_ptr++;
-      while (NUMERIC(*cmd_ptr))
-        subcode = (subcode * 10) + (*cmd_ptr++ - '0');
-    }
-  #endif
-
-  // Skip all spaces to get to the first argument, or nul
-  while (*cmd_ptr == ' ') cmd_ptr++;
-
-  // The command's arguments (if any) start here, for sure!
-  current_command_args = cmd_ptr;
-
   KEEPALIVE_STATE(IN_HANDLER);
 
+  // Parse the next command in the queue
+  parser.parse(current_command);
+
   // Handle a known G, M, or T
-  switch (command_code) {
-    case 'G': switch (codenum) {
+  switch (parser.command_letter) {
+    case 'G': switch (parser.codenum) {
 
       // G0, G1
       case 0:
       case 1:
         #if IS_SCARA
-          gcode_G0_G1(codenum == 0);
+          gcode_G0_G1(parser.codenum == 0);
         #else
           gcode_G0_G1();
         #endif
@@ -10056,7 +9878,7 @@ void process_next_command() {
       #if ENABLED(ARC_SUPPORT) && DISABLED(SCARA)
         case 2: // G2  - CW ARC
         case 3: // G3  - CCW ARC
-          gcode_G2_G3(codenum == 2);
+          gcode_G2_G3(parser.codenum == 2);
           break;
       #endif
 
@@ -10075,7 +9897,7 @@ void process_next_command() {
       #if ENABLED(FWRETRACT)
         case 10: // G10: retract
         case 11: // G11: retract_recover
-          gcode_G10_G11(codenum == 10);
+          gcode_G10_G11(parser.codenum == 10);
           break;
       #endif // FWRETRACT
 
@@ -10170,10 +9992,15 @@ void process_next_command() {
           break;
       #endif
 
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        case 800:
+          parser.debug(); // GCode Parser Test for G
+          break;
+      #endif
     }
     break;
 
-    case 'M': switch (codenum) {
+    case 'M': switch (parser.codenum) {
       #if HAS_RESUME_CONTINUE
         case 0: // M0: Unconditional stop - Wait for user button press on LCD
         case 1: // M1: Conditional stop - Wait for user button press on LCD
@@ -10764,6 +10591,12 @@ void process_next_command() {
         gcode_M355();
         break;
 
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        case 800:
+          parser.debug(); // GCode Parser Test for M
+          break;
+      #endif
+
       case 999: // M999: Restart after being Stopped
         gcode_M999();
         break;
@@ -10771,19 +10604,14 @@ void process_next_command() {
     break;
 
     case 'T':
-      gcode_T(codenum);
+      gcode_T(parser.codenum);
       break;
 
-    default: code_is_good = false;
+    default: parser.unknown_command_error();
   }
 
   KEEPALIVE_STATE(NOT_BUSY);
 
-ExitUnknownCommand:
-
-  // Still unknown command? Throw an error
-  if (!code_is_good) unknown_command_error();
-
   ok_to_send();
 }
 
@@ -12163,7 +11991,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
 
   if (max_inactive_time && ELAPSED(ms, previous_cmd_ms + max_inactive_time)) {
     SERIAL_ERROR_START;
-    SERIAL_ECHOLNPAIR(MSG_KILL_INACTIVE_TIME, current_command);
+    SERIAL_ECHOLNPAIR(MSG_KILL_INACTIVE_TIME, parser.command_ptr);
     kill(PSTR(MSG_KILLED));
   }
 
diff --git a/Marlin/configuration_store.cpp b/Marlin/configuration_store.cpp
index 85780fbc3..f23ee7770 100644
--- a/Marlin/configuration_store.cpp
+++ b/Marlin/configuration_store.cpp
@@ -178,6 +178,10 @@ MarlinSettings settings;
 #include "temperature.h"
 #include "ultralcd.h"
 
+#if ENABLED(INCH_MODE_SUPPORT) || (ENABLED(ULTIPANEL) && ENABLED(TEMPERATURE_UNITS_SUPPORT))
+  #include "gcode.h"
+#endif
+
 #if ENABLED(MESH_BED_LEVELING)
   #include "mesh_bed_leveling.h"
 #endif
@@ -1331,13 +1335,12 @@ void MarlinSettings::reset() {
      */
     CONFIG_ECHO_START;
     #if ENABLED(INCH_MODE_SUPPORT)
-      extern float linear_unit_factor, volumetric_unit_factor;
-      #define LINEAR_UNIT(N) ((N) / linear_unit_factor)
-      #define VOLUMETRIC_UNIT(N) ((N) / (volumetric_enabled ? volumetric_unit_factor : linear_unit_factor))
+      #define LINEAR_UNIT(N) ((N) / parser.linear_unit_factor)
+      #define VOLUMETRIC_UNIT(N) ((N) / (volumetric_enabled ? parser.volumetric_unit_factor : parser.linear_unit_factor))
       SERIAL_ECHOPGM("  G2");
-      SERIAL_CHAR(linear_unit_factor == 1.0 ? '1' : '0');
+      SERIAL_CHAR(parser.linear_unit_factor == 1.0 ? '1' : '0');
       SERIAL_ECHOPGM(" ; Units in ");
-      serialprintPGM(linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
+      serialprintPGM(parser.linear_unit_factor == 1.0 ? PSTR("mm\n") : PSTR("inches\n"));
     #else
       #define LINEAR_UNIT(N) N
       #define VOLUMETRIC_UNIT(N) N
@@ -1351,13 +1354,11 @@ void MarlinSettings::reset() {
 
       CONFIG_ECHO_START;
       #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
-        extern TempUnit input_temp_units;
-        extern float to_temp_units(const float &f);
-        #define TEMP_UNIT(N) to_temp_units(N)
+        #define TEMP_UNIT(N) parser.to_temp_units(N)
         SERIAL_ECHOPGM("  M149 ");
-        SERIAL_CHAR(input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C');
+        SERIAL_CHAR(parser.temp_units_code());
         SERIAL_ECHOPGM(" ; Units in ");
-        serialprintPGM(input_temp_units == TEMPUNIT_K ? PSTR("Kelvin\n") : input_temp_units == TEMPUNIT_F ? PSTR("Fahrenheit\n") : PSTR("Celsius\n"));
+        serialprintPGM(parser.temp_units_name());
       #else
         #define TEMP_UNIT(N) N
         SERIAL_ECHOLNPGM("  M149 C ; Units in Celsius\n");
diff --git a/Marlin/gcode.cpp b/Marlin/gcode.cpp
new file mode 100644
index 000000000..caceb09bd
--- /dev/null
+++ b/Marlin/gcode.cpp
@@ -0,0 +1,279 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+/**
+ * gcode.cpp - Parser for a GCode line, providing a parameter interface.
+ */
+
+#include "gcode.h"
+
+#include "Marlin.h"
+#include "language.h"
+
+// Must be declared for allocation and to satisfy the linker
+// Zero values need no initialization.
+
+#if ENABLED(INCH_MODE_SUPPORT)
+  float GCodeParser::linear_unit_factor, GCodeParser::volumetric_unit_factor;
+#endif
+
+#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
+  TempUnit GCodeParser::input_temp_units;
+#endif
+
+char *GCodeParser::command_ptr,
+     *GCodeParser::string_arg,
+     *GCodeParser::value_ptr;
+char GCodeParser::command_letter;
+int GCodeParser::codenum;
+#if USE_GCODE_SUBCODES
+  int GCodeParser::subcode;
+#endif
+
+#if ENABLED(FASTER_GCODE_PARSER)
+  // Optimized Parameters
+  byte GCodeParser::codebits[4];   // found bits
+  uint8_t GCodeParser::param[26];  // parameter offsets from command_ptr
+#else
+  char *GCodeParser::command_args; // start of parameters
+#endif
+
+// Create a global instance of the GCode parser singleton
+GCodeParser parser;
+
+/**
+ * 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)
+ */
+void GCodeParser::reset() {
+  string_arg = NULL;                    // 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)
+    ZERO(codebits);                     // No codes yet
+    //ZERO(param);                      // No parameters (should be safe to comment out this line)
+  #endif
+}
+
+// Populate all fields by parsing a single line of GCode
+// 58 bytes of SRAM are used to speed up seen/value
+void GCodeParser::parse(char *p) {
+
+  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';
+  }
+
+  // Bail if the letter is not G, M, or T
+  switch (letter) { case 'G': case 'M': case 'T': break; default: return; }
+
+  // Skip spaces to get the numeric part
+  while (*p == ' ') p++;
+
+  // 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++;
+
+  // 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) { case 23: case 28: case 30: case 117: 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!"
+   */
+  string_arg = NULL;
+  while (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) {
+
+      const bool has_num = DECIMAL_SIGNED(*p);  // The parameter has a number [-+0-9.]
+
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        if (debug) {
+          SERIAL_ECHOPAIR("Got letter ", code); // DEBUG
+          SERIAL_ECHOPAIR(" at index ", (int)(p - command_ptr - 1)); // DEBUG
+          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 : NULL            // Set parameter exists and pointer (NULL for no number)
+          #if ENABLED(DEBUG_GCODE_PARSER)
+            , debug
+          #endif
+        );
+      #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
+    }
+
+    while (*p && *p != ' ') p++;                // Skip over the parameter
+    while (*p == ' ') p++;                      // Skip over all spaces
+  }
+}
+
+void GCodeParser::unknown_command_error() {
+  SERIAL_ECHO_START;
+  SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, command_ptr);
+  SERIAL_CHAR('"');
+  SERIAL_EOL;
+}
+
+#if ENABLED(DEBUG_GCODE_PARSER)
+
+  void GCodeParser::debug() {
+    SERIAL_ECHOPAIR("Command: ", command_ptr);
+    SERIAL_ECHOPAIR(" (", command_letter);
+    SERIAL_ECHO(codenum);
+    SERIAL_ECHOLNPGM(")");
+    #if ENABLED(FASTER_GCODE_PARSER)
+      SERIAL_ECHO(" args: \"");
+      for (char c = 'A'; c <= 'Z'; ++c)
+        if (seen(c)) { SERIAL_CHAR(c); SERIAL_CHAR(' '); }
+    #else
+      SERIAL_ECHOPAIR(" args: \"", command_args);
+    #endif
+    SERIAL_ECHOPGM("\"");
+    if (string_arg) {
+      SERIAL_ECHOPGM(" string: \"");
+      SERIAL_ECHO(string_arg);
+      SERIAL_CHAR('"');
+    }
+    SERIAL_ECHOPGM("\n\n");
+    for (char c = 'A'; c <= 'Z'; ++c) {
+      if (seen(c)) {
+        SERIAL_ECHOPAIR("Code '", c); SERIAL_ECHOPGM("':");
+        if (has_value()) {
+          SERIAL_ECHOPAIR("\n    float: ", value_float());
+          SERIAL_ECHOPAIR("\n     long: ", value_long());
+          SERIAL_ECHOPAIR("\n    ulong: ", value_ulong());
+          SERIAL_ECHOPAIR("\n   millis: ", value_millis());
+          SERIAL_ECHOPAIR("\n   sec-ms: ", value_millis_from_seconds());
+          SERIAL_ECHOPAIR("\n      int: ", value_int());
+          SERIAL_ECHOPAIR("\n   ushort: ", value_ushort());
+          SERIAL_ECHOPAIR("\n     byte: ", (int)value_byte());
+          SERIAL_ECHOPAIR("\n     bool: ", (int)value_bool());
+          SERIAL_ECHOPAIR("\n   linear: ", value_linear_units());
+          SERIAL_ECHOPAIR("\n  celsius: ", value_celsius());
+        }
+        else
+          SERIAL_ECHOPGM(" (no value)");
+        SERIAL_ECHOPGM("\n\n");
+      }
+    }
+  }
+
+#endif // DEBUG_GCODE_PARSER
diff --git a/Marlin/gcode.h b/Marlin/gcode.h
new file mode 100644
index 000000000..8348f5646
--- /dev/null
+++ b/Marlin/gcode.h
@@ -0,0 +1,285 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016 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/>.
+ *
+ */
+
+/**
+ * gcode.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.
+ */
+
+#ifndef GCODE_H
+#define GCODE_H
+
+#include "enum.h"
+#include "types.h"
+#include "MarlinConfig.h"
+
+//#define DEBUG_GCODE_PARSER
+
+#if ENABLED(DEBUG_GCODE_PARSER)
+  #include "hex_print_routines.h"
+  #include "serial.h"
+#endif
+
+#if ENABLED(INCH_MODE_SUPPORT)
+  extern bool volumetric_enabled;
+#endif
+
+/**
+ * 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
+ */
+class GCodeParser {
+
+private:
+  static char *value_ptr;           // Set by seen, used to fetch the value
+
+  #if ENABLED(FASTER_GCODE_PARSER)
+    static byte codebits[4];        // Parameters pre-scanned
+    static uint8_t param[26];       // For A-Z, offsets into command args
+  #else
+    static char *command_args;      // Args start here, for slow scan
+  #endif
+
+public:
+
+  // Global states for GCode-level units features
+
+  #if ENABLED(INCH_MODE_SUPPORT)
+    static float linear_unit_factor, volumetric_unit_factor;
+  #endif
+
+  #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
+    static TempUnit input_temp_units;
+  #endif
+
+  // Command line state
+  static char *command_ptr,               // The command, so it can be echoed
+              *string_arg;                // string of command line
+
+  static char command_letter;             // G, M, or T
+  static int codenum;                     // 123
+  #if USE_GCODE_SUBCODES
+    static int subcode;                   // .1
+  #endif
+
+  #if ENABLED(DEBUG_GCODE_PARSER)
+    void debug();
+  #endif
+
+  // Reset is done before parsing
+  static void reset();
+
+  #if ENABLED(FASTER_GCODE_PARSER)
+
+    // Set the flag and pointer for a parameter
+    static void set(const char c, char * const ptr
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        , const bool debug=false
+      #endif
+    ) {
+      const uint8_t ind = c - 'A';
+      if (ind >= COUNT(param)) return;           // Only A-Z
+      SBI(codebits[ind >> 3], ind & 0x7);        // parameter exists
+      param[ind] = ptr ? ptr - command_ptr : 0;  // parameter offset or 0
+      #if ENABLED(DEBUG_GCODE_PARSER)
+        if (debug) {
+          SERIAL_ECHOPAIR("Set bit ", (int)(ind & 0x7));
+          SERIAL_ECHOPAIR(" of index ", (int)(ind >> 3));
+          SERIAL_ECHOLNPAIR(" | param = ", hex_address((void*)param[ind]));
+        }
+      #endif
+    }
+
+    // Code seen bit was set. If not found, value_ptr is unchanged.
+    // This allows "if (seen('A')||seen('B'))" to use the last-found value.
+    static bool seen(const char c) {
+      const uint8_t ind = c - 'A';
+      if (ind >= COUNT(param)) return false; // Only A-Z
+      const bool b = TEST(codebits[ind >> 3], ind & 0x7);
+      if (b) value_ptr = command_ptr + param[ind];
+      return b;
+    }
+
+  #else
+
+    // Code is found in the string. If not found, value_ptr is unchanged.
+    // This allows "if (seen('A')||seen('B'))" to use the last-found value.
+    static bool seen(const char c) {
+      char *p = strchr(command_args, c);
+      const bool b = !!p;
+      if (b) value_ptr = DECIMAL_SIGNED(*p) ? p + 1 : NULL;
+      return b;
+    }
+
+  #endif // FASTER_GCODE_PARSER
+
+  // Populate all fields by parsing a single line of GCode
+  // This uses 54 bytes of SRAM to speed up seen/value
+  static void parse(char * p);
+
+  // Code value pointer was set
+  FORCE_INLINE static bool has_value() { return value_ptr != NULL; }
+
+  // Float removes 'E' to prevent scientific notation interpretation
+  inline static float value_float() {
+    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 = strtod(value_ptr, NULL);
+          *e = c;
+          return ret;
+        }
+        ++e;
+      }
+      return strtod(value_ptr, NULL);
+    }
+    return 0.0;
+  }
+
+  // Code value as a long or ulong
+  inline          static long value_long()  { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
+  inline unsigned static long value_ulong() { return value_ptr ? strtoul(value_ptr, NULL, 10) : 0UL; }
+
+  // Code value for use as time
+  FORCE_INLINE static millis_t value_millis() { return value_ulong(); }
+  FORCE_INLINE static millis_t value_millis_from_seconds() { return value_float() * 1000UL; }
+
+  // Reduce to fewer bits
+  FORCE_INLINE static int value_int()    { return (int)value_long(); }
+  FORCE_INLINE uint16_t value_ushort()   { return (uint16_t)value_long(); }
+  inline static uint8_t value_byte()     { return (uint8_t)(constrain(value_long(), 0, 255)); }
+
+  // Bool is true with no value or non-zero
+  inline static bool value_bool()        { return !has_value() || value_byte(); }
+
+  // Units modes: Inches, Fahrenheit, Kelvin
+
+  #if ENABLED(INCH_MODE_SUPPORT)
+
+    inline static void set_input_linear_units(LinearUnit units) {
+      switch (units) {
+        case LINEARUNIT_INCH:
+          linear_unit_factor = 25.4;
+          break;
+        case LINEARUNIT_MM:
+        default:
+          linear_unit_factor = 1.0;
+          break;
+      }
+      volumetric_unit_factor = pow(linear_unit_factor, 3.0);
+    }
+
+    inline static float axis_unit_factor(const AxisEnum axis) {
+      return (axis >= E_AXIS && volumetric_enabled ? volumetric_unit_factor : linear_unit_factor);
+    }
+
+    inline static float value_linear_units()                     { return value_float() * linear_unit_factor; }
+    inline static float value_axis_units(const AxisEnum axis)    { return value_float() * axis_unit_factor(axis); }
+    inline static float value_per_axis_unit(const AxisEnum axis) { return value_float() / axis_unit_factor(axis); }
+
+  #else
+
+    FORCE_INLINE static float value_linear_units()                  {            return value_float(); }
+    FORCE_INLINE static float value_axis_units(const AxisEnum a)    { UNUSED(a); return value_float(); }
+    FORCE_INLINE static float value_per_axis_unit(const AxisEnum a) { UNUSED(a); return value_float(); }
+
+  #endif
+
+  #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
+
+    inline static void set_input_temp_units(TempUnit units) { input_temp_units = units; }
+
+    #if ENABLED(ULTIPANEL) && DISABLED(DISABLE_M503)
+
+      FORCE_INLINE static char temp_units_code() {
+        return input_temp_units == TEMPUNIT_K ? 'K' : input_temp_units == TEMPUNIT_F ? 'F' : 'C';
+      }
+      FORCE_INLINE static char* temp_units_name() {
+        return input_temp_units == TEMPUNIT_K ? PSTR("Kelvin") : input_temp_units == TEMPUNIT_F ? PSTR("Fahrenheit") : PSTR("Celsius")
+      }
+      inline static float to_temp_units(const float &f) {
+        switch (input_temp_units) {
+          case TEMPUNIT_F:
+            return f * 0.5555555556 + 32.0;
+          case TEMPUNIT_K:
+            return f + 273.15;
+          case TEMPUNIT_C:
+          default:
+            return f;
+        }
+      }
+
+    #endif // ULTIPANEL && !DISABLE_M503
+
+    inline static float value_celsius() {
+      const float f = value_float();
+      switch (input_temp_units) {
+        case TEMPUNIT_F:
+          return (f - 32.0) * 0.5555555556;
+        case TEMPUNIT_K:
+          return f - 273.15;
+        case TEMPUNIT_C:
+        default:
+          return f;
+      }
+    }
+
+    inline static float value_celsius_diff() {
+      switch (input_temp_units) {
+        case TEMPUNIT_F:
+          return value_float() * 0.5555555556;
+        case TEMPUNIT_C:
+        case TEMPUNIT_K:
+        default:
+          return value_float();
+      }
+    }
+
+  #else
+
+    FORCE_INLINE static float value_celsius()      { return value_float(); }
+    FORCE_INLINE static float value_celsius_diff() { return value_float(); }
+
+  #endif
+
+  FORCE_INLINE static float value_feedrate() { return value_linear_units(); }
+
+  void unknown_command_error();
+
+};
+
+extern GCodeParser parser;
+
+#endif // GCODE_H
diff --git a/Marlin/hex_print_routines.cpp b/Marlin/hex_print_routines.cpp
index 39e5b4cd7..65b97fc18 100644
--- a/Marlin/hex_print_routines.cpp
+++ b/Marlin/hex_print_routines.cpp
@@ -20,7 +20,9 @@
  *
  */
 #include "Marlin.h"
-#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
+#include "gcode.h"
+
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER) || ENABLED(DEBUG_GCODE_PARSER)
 
 #include "hex_print_routines.h"
 
@@ -50,4 +52,4 @@ void print_hex_byte(const uint8_t b)         { SERIAL_ECHO(hex_byte(b));    }
 void print_hex_word(const uint16_t w)        { SERIAL_ECHO(hex_word(w));    }
 void print_hex_address(const void * const w) { SERIAL_ECHO(hex_address(w)); }
 
-#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER
+#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER || DEBUG_GCODE_PARSER
diff --git a/Marlin/hex_print_routines.h b/Marlin/hex_print_routines.h
index ea4073331..1ca61e311 100644
--- a/Marlin/hex_print_routines.h
+++ b/Marlin/hex_print_routines.h
@@ -24,8 +24,9 @@
 #define HEX_PRINT_ROUTINES_H
 
 #include "MarlinConfig.h"
+#include "gcode.h"
 
-#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER)
+#if ENABLED(AUTO_BED_LEVELING_UBL) || ENABLED(M100_FREE_MEMORY_WATCHER) || ENABLED(DEBUG_GCODE_PARSER)
 
 //
 // Utility functions to create and print hex strings as nybble, byte, and word.
@@ -43,5 +44,5 @@ void print_hex_byte(const uint8_t b);
 void print_hex_word(const uint16_t w);
 void print_hex_address(const void * const w);
 
-#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER
+#endif // AUTO_BED_LEVELING_UBL || M100_FREE_MEMORY_WATCHER || DEBUG_GCODE_PARSER
 #endif // HEX_PRINT_ROUTINES_H
diff --git a/Marlin/macros.h b/Marlin/macros.h
index e7283f867..0fb057441 100644
--- a/Marlin/macros.h
+++ b/Marlin/macros.h
@@ -124,7 +124,9 @@
 
 #define WITHIN(V,L,H) ((V) >= (L) && (V) <= (H))
 #define NUMERIC(a) WITHIN(a, '0', '9')
-#define NUMERIC_SIGNED(a) (NUMERIC(a) || (a) == '-')
+#define DECIMAL(a) (NUMERIC(a) || a == '.')
+#define NUMERIC_SIGNED(a) (NUMERIC(a) || (a) == '-' || (a) == '+')
+#define DECIMAL_SIGNED(a) (DECIMAL(a) || (a) == '-' || (a) == '+')
 #define COUNT(a) (sizeof(a)/sizeof(*a))
 #define ZERO(a) memset(a,0,sizeof(a))
 #define COPY(a,b) memcpy(a,b,min(sizeof(a),sizeof(b)))
diff --git a/Marlin/planner.cpp b/Marlin/planner.cpp
index 155a4717f..44b1a36f4 100644
--- a/Marlin/planner.cpp
+++ b/Marlin/planner.cpp
@@ -64,6 +64,7 @@
 #include "ultralcd.h"
 #include "language.h"
 #include "ubl.h"
+#include "gcode.h"
 
 #include "Marlin.h"
 
@@ -1549,10 +1550,10 @@ void Planner::refresh_positioning() {
 #if ENABLED(AUTOTEMP)
 
   void Planner::autotemp_M104_M109() {
-    autotemp_enabled = code_seen('F');
-    if (autotemp_enabled) autotemp_factor = code_value_temp_diff();
-    if (code_seen('S')) autotemp_min = code_value_temp_abs();
-    if (code_seen('B')) autotemp_max = code_value_temp_abs();
+    autotemp_enabled = parser.seen('F');
+    if (autotemp_enabled) autotemp_factor = parser.value_celsius_diff();
+    if (parser.seen('S')) autotemp_min = parser.value_celsius();
+    if (parser.seen('B')) autotemp_max = parser.value_celsius();
   }
 
 #endif
diff --git a/Marlin/ubl_G29.cpp b/Marlin/ubl_G29.cpp
index 381ab28ab..c9abfbd5c 100644
--- a/Marlin/ubl_G29.cpp
+++ b/Marlin/ubl_G29.cpp
@@ -30,6 +30,7 @@
   #include "configuration_store.h"
   #include "ultralcd.h"
   #include "stepper.h"
+  #include "gcode.h"
 
   #include <math.h>
   #include "least_squares_fit.h"
@@ -47,10 +48,6 @@
   float lcd_z_offset_edit();
   extern float meshedit_done;
   extern long babysteps_done;
-  extern float code_value_float();
-  extern uint8_t code_value_byte();
-  extern bool code_value_bool();
-  extern bool code_has_value();
   extern float probe_pt(const float &x, const float &y, bool, int);
   extern bool set_probe_deployed(bool);
 
@@ -322,26 +319,20 @@
       return;
     }
 
-    // Check for commands that require the printer to be homed.
+    // Check for commands that require the printer to be homed
     if (axis_unhomed_error()) {
-      if (code_seen('J'))
+      const int8_t p_val = parser.seen('P') && parser.has_value() ? parser.value_int() : -1;
+      if (p_val == 1 || p_val == 2 || p_val == 4 || parser.seen('J'))
         home_all_axes();
-      else if (code_seen('P')) {
-        if (code_has_value()) {
-          const int p_val = code_value_int();
-          if (p_val == 1 || p_val == 2 || p_val == 4)
-            home_all_axes();
-        }
-      }
     }
 
     if (g29_parameter_parsing()) return; // abort if parsing the simple parameters causes a problem,
 
-    // Invalidate Mesh Points. This command is a little bit asymetrical because
+    // Invalidate Mesh Points. This command is a little bit asymmetrical because
     // it directly specifies the repetition count and does not use the 'R' parameter.
-    if (code_seen('I')) {
+    if (parser.seen('I')) {
       uint8_t cnt = 0;
-      g29_repetition_cnt = code_has_value() ? code_value_int() : 1;
+      g29_repetition_cnt = parser.has_value() ? parser.value_int() : 1;
       while (g29_repetition_cnt--) {
         if (cnt > 20) { cnt = 0; idle(); }
         const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, g29_x_pos, g29_y_pos, USE_NOZZLE_AS_REFERENCE, NULL, false);
@@ -355,10 +346,10 @@
       SERIAL_PROTOCOLLNPGM("Locations invalidated.\n");
     }
 
-    if (code_seen('Q')) {
-      const int test_pattern = code_has_value() ? code_value_int() : -99;
+    if (parser.seen('Q')) {
+      const int test_pattern = parser.has_value() ? parser.value_int() : -99;
       if (!WITHIN(test_pattern, -1, 2)) {
-        SERIAL_PROTOCOLLNPGM("Invalid test_pattern value. (0-2)\n");
+        SERIAL_PROTOCOLLNPGM("Invalid test_pattern value. (-1 to 2)\n");
         return;
       }
       SERIAL_PROTOCOLLNPGM("Loading test_pattern values.\n");
@@ -385,15 +376,15 @@
           // Allow the user to specify the height because 10mm is a little extreme in some cases.
           for (uint8_t x = (GRID_MAX_POINTS_X) / 3; x < 2 * (GRID_MAX_POINTS_X) / 3; x++)   // Create a rectangular raised area in
             for (uint8_t y = (GRID_MAX_POINTS_Y) / 3; y < 2 * (GRID_MAX_POINTS_Y) / 3; y++) // the center of the bed
-              z_values[x][y] += code_seen('C') ? g29_constant : 9.99;
+              z_values[x][y] += parser.seen('C') ? g29_constant : 9.99;
           break;
       }
     }
 
-    if (code_seen('J')) {
+    if (parser.seen('J')) {
       if (g29_grid_size) {  // if not 0 it is a normal n x n grid being probed
         save_ubl_active_state_and_disable();
-        tilt_mesh_based_on_probed_grid(code_seen('T'));
+        tilt_mesh_based_on_probed_grid(parser.seen('T'));
         restore_ubl_active_state_and_leave();
       }
       else { // grid_size == 0 : A 3-Point leveling has been requested
@@ -425,7 +416,7 @@
       }
     }
 
-    if (code_seen('P')) {
+    if (parser.seen('P')) {
       if (WITHIN(g29_phase_value, 0, 1) && state.storage_slot == -1) {
         state.storage_slot = 0;
         SERIAL_PROTOCOLLNPGM("Default storage slot 0 selected.");
@@ -444,7 +435,7 @@
           //
           // Invalidate Entire Mesh and Automatically Probe Mesh in areas that can be reached by the probe
           //
-          if (!code_seen('C')) {
+          if (!parser.seen('C')) {
             invalidate();
             SERIAL_PROTOCOLLNPGM("Mesh invalidated. Probing mesh.");
           }
@@ -455,7 +446,7 @@
             SERIAL_PROTOCOLLNPGM(").\n");
           }
           probe_entire_mesh(g29_x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, g29_y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER,
-                            code_seen('T'), code_seen('E'), code_seen('U'));
+                            parser.seen('T'), parser.seen('E'), parser.seen('U'));
           break;
 
         case 2: {
@@ -481,30 +472,29 @@
             #endif
           }
 
-          if (code_seen('C')) {
+          if (parser.seen('C')) {
             g29_x_pos = current_position[X_AXIS];
             g29_y_pos = current_position[Y_AXIS];
           }
 
           float height = Z_CLEARANCE_BETWEEN_PROBES;
 
-          if (code_seen('B')) {
-            g29_card_thickness = code_has_value() ? code_value_float() : measure_business_card_thickness(height);
-
+          if (parser.seen('B')) {
+            g29_card_thickness = parser.has_value() ? parser.value_float() : measure_business_card_thickness(height);
             if (fabs(g29_card_thickness) > 1.5) {
               SERIAL_PROTOCOLLNPGM("?Error in Business Card measurement.");
               return;
             }
           }
 
-          if (code_seen('H') && code_has_value()) height = code_value_float();
+          if (parser.seen('H') && parser.has_value()) height = parser.value_float();
 
           if (!position_is_reachable_xy(g29_x_pos, g29_y_pos)) {
-            SERIAL_PROTOCOLLNPGM("(X,Y) outside printable radius.");
+            SERIAL_PROTOCOLLNPGM("XY outside printable radius.");
             return;
           }
 
-          manually_probe_remaining_mesh(g29_x_pos, g29_y_pos, height, g29_card_thickness, code_seen('T'));
+          manually_probe_remaining_mesh(g29_x_pos, g29_y_pos, height, g29_card_thickness, parser.seen('T'));
           SERIAL_PROTOCOLLNPGM("G29 P2 finished.");
         } break;
 
@@ -531,7 +521,7 @@
               }
             }
           } else {
-            const float cvf = code_value_float();
+            const float cvf = parser.value_float();
             switch((int)truncf(cvf * 10.0) - 30) {   // 3.1 -> 1
               #if ENABLED(UBL_G29_P31)
                 case 1: {
@@ -561,9 +551,7 @@
           //
           // Fine Tune (i.e., Edit) the Mesh
           //
-
-          fine_tune_mesh(g29_x_pos, g29_y_pos, code_seen('T'));
-
+          fine_tune_mesh(g29_x_pos, g29_y_pos, parser.seen('T'));
           break;
 
         case 5: find_mean_mesh_height(); break;
@@ -576,22 +564,22 @@
     // Much of the 'What?' command can be eliminated. But until we are fully debugged, it is
     // good to have the extra information. Soon... we prune this to just a few items
     //
-    if (code_seen('W')) g29_what_command();
+    if (parser.seen('W')) g29_what_command();
 
     //
     // When we are fully debugged, this may go away. But there are some valid
     // use cases for the users. So we can wait and see what to do with it.
     //
 
-    if (code_seen('K')) // Kompare Current Mesh Data to Specified Stored Mesh
+    if (parser.seen('K')) // Kompare Current Mesh Data to Specified Stored Mesh
       g29_compare_current_mesh_to_stored_mesh();
 
     //
     // Load a Mesh from the EEPROM
     //
 
-    if (code_seen('L')) {     // Load Current Mesh Data
-      g29_storage_slot = code_has_value() ? code_value_int() : state.storage_slot;
+    if (parser.seen('L')) {     // Load Current Mesh Data
+      g29_storage_slot = parser.has_value() ? parser.value_int() : state.storage_slot;
 
       int16_t a = settings.calc_num_meshes();
 
@@ -616,8 +604,8 @@
     // Store a Mesh in the EEPROM
     //
 
-    if (code_seen('S')) {     // Store (or Save) Current Mesh Data
-      g29_storage_slot = code_has_value() ? code_value_int() : state.storage_slot;
+    if (parser.seen('S')) {     // Store (or Save) Current Mesh Data
+      g29_storage_slot = parser.has_value() ? parser.value_int() : state.storage_slot;
 
       if (g29_storage_slot == -1) {                     // Special case, we are going to 'Export' the mesh to the
         SERIAL_ECHOLNPGM("G29 I 999");              // host in a form it can be reconstructed on a different machine
@@ -654,15 +642,17 @@
       SERIAL_PROTOCOLLNPGM("Done.");
     }
 
-    if (code_seen('T'))
-      display_map(code_has_value() ? code_value_int() : 0);
+    if (parser.seen('T'))
+      display_map(parser.has_value() ? parser.value_int() : 0);
 
-    /*
+    /**
      * This code may not be needed...  Prepare for its removal...
      *
-    if (code_seen('Z')) {
-      if (code_has_value())
-        state.z_offset = code_value_float();   // do the simple case. Just lock in the specified value
+     */
+    #if 0
+    if (parser.seen('Z')) {
+      if (parser.has_value())
+        state.z_offset = parser.value_float();   // do the simple case. Just lock in the specified value
       else {
         save_ubl_active_state_and_disable();
         //float measured_z = probe_pt(g29_x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, g29_y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER, ProbeDeployAndStow, g29_verbose_level);
@@ -712,7 +702,7 @@
         restore_ubl_active_state_and_leave();
       }
     }
-    */
+    #endif
 
     LEAVE:
 
@@ -1015,10 +1005,7 @@
 
       if (do_ubl_mesh_map) display_map(g29_map_type);  // show user where we're probing
 
-      if (code_seen('B'))
-        LCD_MESSAGEPGM("Place shim & measure"); // TODO: Make translatable string
-      else
-        LCD_MESSAGEPGM("Measure"); // TODO: Make translatable string
+      serialprintPGM(parser.seen('B') ? PSTR("Place shim & measure") : PSTR("Measure")); // TODO: Make translatable strings
 
       while (ubl_lcd_clicked()) delay(50);             // wait for user to release encoder wheel
       delay(50);                                       // debounce
@@ -1073,13 +1060,13 @@
     g29_constant = 0.0;
     g29_repetition_cnt = 0;
 
-    g29_x_flag = code_seen('X') && code_has_value();
-    g29_x_pos = g29_x_flag ? code_value_float() : current_position[X_AXIS];
-    g29_y_flag = code_seen('Y') && code_has_value();
-    g29_y_pos = g29_y_flag ? code_value_float() : current_position[Y_AXIS];
+    g29_x_flag = parser.seen('X') && parser.has_value();
+    g29_x_pos = g29_x_flag ? parser.value_float() : current_position[X_AXIS];
+    g29_y_flag = parser.seen('Y') && parser.has_value();
+    g29_y_pos = g29_y_flag ? parser.value_float() : current_position[Y_AXIS];
 
-    if (code_seen('R')) {
-      g29_repetition_cnt = code_has_value() ? code_value_int() : GRID_MAX_POINTS;
+    if (parser.seen('R')) {
+      g29_repetition_cnt = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS;
       NOMORE(g29_repetition_cnt, GRID_MAX_POINTS);
       if (g29_repetition_cnt < 1) {
         SERIAL_PROTOCOLLNPGM("?(R)epetition count invalid (1+).\n");
@@ -1087,22 +1074,22 @@
       }
     }
 
-    g29_verbose_level = code_seen('V') ? code_value_int() : 0;
+    g29_verbose_level = parser.seen('V') ? parser.value_int() : 0;
     if (!WITHIN(g29_verbose_level, 0, 4)) {
       SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).\n");
       err_flag = true;
     }
 
-    if (code_seen('P')) {
-      g29_phase_value = code_value_int();
+    if (parser.seen('P')) {
+      g29_phase_value = parser.value_int();
       if (!WITHIN(g29_phase_value, 0, 6)) {
         SERIAL_PROTOCOLLNPGM("?(P)hase value invalid (0-6).\n");
         err_flag = true;
       }
     }
 
-    if (code_seen('J')) {
-      g29_grid_size = code_has_value() ? code_value_int() : 0;
+    if (parser.seen('J')) {
+      g29_grid_size = parser.has_value() ? parser.value_int() : 0;
       if (g29_grid_size && !WITHIN(g29_grid_size, 2, 9)) {
         SERIAL_PROTOCOLLNPGM("?Invalid grid size (J) specified (2-9).\n");
         err_flag = true;
@@ -1125,27 +1112,32 @@
 
     if (err_flag) return UBL_ERR;
 
-    // Activate or deactivate UBL
-    if (code_seen('A')) {
-      if (code_seen('D')) {
+    /**
+     * Activate or deactivate UBL
+     * Note: UBL's G29 restores the state set here when done.
+     *       Leveling is being enabled here with old data, possibly
+     *       none. Error handling should disable for safety...
+     */
+    if (parser.seen('A')) {
+      if (parser.seen('D')) {
         SERIAL_PROTOCOLLNPGM("?Can't activate and deactivate at the same time.\n");
         return UBL_ERR;
       }
       state.active = true;
       report_state();
     }
-    else if (code_seen('D')) {
+    else if (parser.seen('D')) {
       state.active = false;
       report_state();
     }
 
     // Set global 'C' flag and its value
-    if ((g29_c_flag = code_seen('C')))
-      g29_constant = code_value_float();
+    if ((g29_c_flag = parser.seen('C')))
+      g29_constant = parser.value_float();
 
     #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
-      if (code_seen('F') && code_has_value()) {
-        const float fh = code_value_float();
+      if (parser.seen('F') && parser.has_value()) {
+        const float fh = parser.value_float();
         if (!WITHIN(fh, 0.0, 100.0)) {
           SERIAL_PROTOCOLLNPGM("?(F)ade height for Bed Level Correction not plausible.\n");
           return UBL_ERR;
@@ -1154,7 +1146,7 @@
       }
     #endif
 
-    g29_map_type = code_seen('T') && code_has_value() ? code_value_int() : 0;
+    g29_map_type = parser.seen('T') && parser.has_value() ? parser.value_int() : 0;
     if (!WITHIN(g29_map_type, 0, 1)) {
       SERIAL_PROTOCOLLNPGM("Invalid map type.\n");
       return UBL_ERR;
@@ -1319,13 +1311,13 @@
       return;
     }
 
-    if (!code_has_value()) {
+    if (!parser.has_value()) {
       SERIAL_PROTOCOLLNPGM("?Storage slot # required.");
       SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
       return;
     }
 
-    g29_storage_slot = code_value_int();
+    g29_storage_slot = parser.value_int();
 
     if (!WITHIN(g29_storage_slot, 0, a - 1)) {
       SERIAL_PROTOCOLLNPGM("?Invalid storage slot.");
@@ -1416,7 +1408,7 @@
   }
 
   void unified_bed_leveling::fine_tune_mesh(const float &lx, const float &ly, const bool do_ubl_mesh_map) {
-    if (!code_seen('R'))    // fine_tune_mesh() is special. If no repetition count flag is specified
+    if (!parser.seen('R'))    // fine_tune_mesh() is special. If no repetition count flag is specified
       g29_repetition_cnt = 1;   // do exactly one mesh location. Otherwise use what the parser decided.
 
     mesh_index_pair location;
@@ -1587,7 +1579,7 @@
       const float x = float(x_min) + ix * dx;
       for (int8_t iy = 0; iy < g29_grid_size; iy++) {
         const float y = float(y_min) + dy * (zig_zag ? g29_grid_size - 1 - iy : iy);
-        float measured_z = probe_pt(LOGICAL_X_POSITION(x), LOGICAL_Y_POSITION(y), code_seen('E'), g29_verbose_level); // TODO: Needs error handling
+        float measured_z = probe_pt(LOGICAL_X_POSITION(x), LOGICAL_Y_POSITION(y), parser.seen('E'), g29_verbose_level); // TODO: Needs error handling
         #if ENABLED(DEBUG_LEVELING_FEATURE)
           if (DEBUGGING(LEVELING)) {
             SERIAL_CHAR('(');