🎨 Apply F() to G-code subcommands

Marlin/src/feature/bedlevel/ubl/ubl.cpp

       }
     #endif
 
-    process_subcommands_now_P(G28_STR);               // Home
-    process_subcommands_now_P(PSTR(ALIGN_GCODE "\n"   // Align multi z axis if available
-                                   PROBE_GCODE "\n"   // Build mesh with available hardware
-                                   "G29P3\nG29P3"));  // Ensure mesh is complete by running smart fill twice
+    process_subcommands_now(FPSTR(G28_STR));      // Home
+    process_subcommands_now(F(ALIGN_GCODE "\n"    // Align multi z axis if available
+                              PROBE_GCODE "\n"    // Build mesh with available hardware
+                              "G29P3\nG29P3"));   // Ensure mesh is complete by running smart fill twice
 
     if (parser.seenval('S')) {
       char umw_gcode[32];
       queue.inject(umw_gcode);
     }
 
-    process_subcommands_now_P(PSTR("G29A\nG29F10\n"   // Set UBL Active & Fade 10
-                                   "M140S0\nM104S0\n" // Turn off heaters
-                                   "M500"));          // Store settings
+    process_subcommands_now(F("G29A\nG29F10\n"    // Set UBL Active & Fade 10
+                              "M140S0\nM104S0\n"  // Turn off heaters
+                              "M500"));           // Store settings
   }
 
 #endif // UBL_MESH_WIZARD

Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp

     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Z Probe End Script: ", Z_PROBE_END_SCRIPT);
     if (probe_deployed) {
       planner.synchronize();
-      gcode.process_subcommands_now_P(PSTR(Z_PROBE_END_SCRIPT));
+      gcode.process_subcommands_now(F(Z_PROBE_END_SCRIPT));
     }
   #else
     UNUSED(probe_deployed);

Marlin/src/feature/power.cpp

   TERN_(HAS_TRINAMIC_CONFIG, safe_delay(PSU_POWERUP_DELAY));
 
   #ifdef PSU_POWERUP_GCODE
-    GcodeSuite::process_subcommands_now_P(PSTR(PSU_POWERUP_GCODE));
+    gcode.process_subcommands_now(F(PSU_POWERUP_GCODE));
   #endif
 }
 
   if (!psu_on) return;
 
   #ifdef PSU_POWEROFF_GCODE
-    GcodeSuite::process_subcommands_now_P(PSTR(PSU_POWEROFF_GCODE));
+    gcode.process_subcommands_now(F(PSU_POWEROFF_GCODE));
   #endif
 
   #if ENABLED(PS_OFF_SOUND)

Marlin/src/feature/powerloss.cpp

 
         #if POWER_LOSS_RETRACT_LEN
           // Retract filament now
-          gcode.process_subcommands_now_P(PSTR("G1 F3000 E-" STRINGIFY(POWER_LOSS_RETRACT_LEN)));
+          gcode.process_subcommands_now(F("G1 F3000 E-" STRINGIFY(POWER_LOSS_RETRACT_LEN)));
         #endif
 
         #if POWER_LOSS_ZRAISE
 
   #if HAS_LEVELING
     // Make sure leveling is off before any G92 and G28
-    gcode.process_subcommands_now_P(PSTR("M420 S0 Z0"));
+    gcode.process_subcommands_now(F("M420 S0 Z0"));
   #endif
 
   #if HAS_HEATED_BED
   // establish the current position as best we can.
   //
 
-  gcode.process_subcommands_now_P(PSTR("G92.9E0")); // Reset E to 0
+  gcode.process_subcommands_now(F("G92.9E0")); // Reset E to 0
 
   #if Z_HOME_TO_MAX
 
     }
 
     // Home XY with no Z raise, and also home Z here if Z isn't homing down below.
-    gcode.process_subcommands_now_P(PSTR("G28R0" TERN_(HOME_XY_ONLY, "XY"))); // No raise during G28
+    gcode.process_subcommands_now(F("G28R0" TERN_(HOME_XY_ONLY, "XY"))); // No raise during G28
 
   #endif
 
 
   // Un-retract if there was a retract at outage
   #if ENABLED(BACKUP_POWER_SUPPLY) && POWER_LOSS_RETRACT_LEN > 0
-    gcode.process_subcommands_now_P(PSTR("G1E" STRINGIFY(POWER_LOSS_RETRACT_LEN) "F3000"));
+    gcode.process_subcommands_now(F("G1E" STRINGIFY(POWER_LOSS_RETRACT_LEN) "F3000"));
   #endif
 
   // Additional purge on resume if configured
   #endif
 
   #if ENABLED(NOZZLE_CLEAN_FEATURE)
-    gcode.process_subcommands_now_P(PSTR("G12"));
+    gcode.process_subcommands_now(F("G12"));
   #endif
 
   // Move back over to the saved XY

Marlin/src/gcode/bedlevel/G35.cpp

   TERN_(HAS_DUPLICATION_MODE, set_duplication_enabled(false));
 
   // Home only Z axis when X and Y is trusted, otherwise all axes, if needed before this procedure
-  if (!all_axes_trusted()) process_subcommands_now_P(PSTR("G28Z"));
+  if (!all_axes_trusted()) process_subcommands_now(F("G28Z"));
 
   bool err_break = false;
 

Marlin/src/gcode/bedlevel/abl/G29.cpp

 
   // Send 'N' to force homing before G29 (internal only)
   if (parser.seen_test('N'))
-    process_subcommands_now_P(TERN(CAN_SET_LEVELING_AFTER_G28, PSTR("G28L0"), G28_STR));
+    process_subcommands_now(TERN(CAN_SET_LEVELING_AFTER_G28, F("G28L0"), FPSTR(G28_STR)));
 
   // Don't allow auto-leveling without homing first
   if (homing_needed_error()) G29_RETURN(false);
   #ifdef Z_PROBE_END_SCRIPT
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Z Probe End Script: ", Z_PROBE_END_SCRIPT);
     planner.synchronize();
-    process_subcommands_now_P(PSTR(Z_PROBE_END_SCRIPT));
+    process_subcommands_now(F(Z_PROBE_END_SCRIPT));
   #endif
 
   TERN_(HAS_DWIN_E3V2_BASIC, DWIN_CompletedLeveling());

Marlin/src/gcode/calibrate/G34.cpp

   TemporaryGlobalEndstopsState unlock_z(false);
 
   #ifdef GANTRY_CALIBRATION_COMMANDS_PRE
-    gcode.process_subcommands_now_P(PSTR(GANTRY_CALIBRATION_COMMANDS_PRE));
+    process_subcommands_now(F(GANTRY_CALIBRATION_COMMANDS_PRE));
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Sub Commands Processed");
   #endif
 
 
   #ifdef GANTRY_CALIBRATION_COMMANDS_POST
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("Running Post Commands");
-    gcode.process_subcommands_now_P(PSTR(GANTRY_CALIBRATION_COMMANDS_POST));
+    process_subcommands_now(F(GANTRY_CALIBRATION_COMMANDS_POST));
   #endif
 
   SET_SOFT_ENDSTOP_LOOSE(false);

Marlin/src/gcode/calibrate/G34_M422.cpp

         // After this operation the z position needs correction
         set_axis_never_homed(Z_AXIS);
         // Home Z after the alignment procedure
-        process_subcommands_now_P(PSTR("G28Z"));
+        process_subcommands_now(F("G28Z"));
       #else
         // Use the probed height from the last iteration to determine the Z height.
         // z_measured_min is used, because all steppers are aligned to z_measured_min.

Marlin/src/gcode/calibrate/G425.cpp

 void GcodeSuite::G425() {
 
   #ifdef CALIBRATION_SCRIPT_PRE
-    GcodeSuite::process_subcommands_now_P(PSTR(CALIBRATION_SCRIPT_PRE));
+    process_subcommands_now(F(CALIBRATION_SCRIPT_PRE));
   #endif
 
   if (homing_needed_error()) return;
   SET_SOFT_ENDSTOP_LOOSE(false);
 
   #ifdef CALIBRATION_SCRIPT_POST
-    GcodeSuite::process_subcommands_now_P(PSTR(CALIBRATION_SCRIPT_POST));
+    process_subcommands_now(F(CALIBRATION_SCRIPT_POST));
   #endif
 }
 

Marlin/src/gcode/calibrate/G76_M192_M871.cpp

       return;
     }
 
-    process_subcommands_now_P(G28_STR);
+    process_subcommands_now(FPSTR(G28_STR));
   }
 
   remember_feedrate_scaling_off();

Marlin/src/gcode/control/M605.cpp

       set_duplication_enabled(false);
 
       #ifdef EVENT_GCODE_IDEX_AFTER_MODECHANGE
-        gcode.process_subcommands_now_P(PSTR(EVENT_GCODE_IDEX_AFTER_MODECHANGE));
+        process_subcommands_now(F(EVENT_GCODE_IDEX_AFTER_MODECHANGE));
       #endif
     }
     else if (!parser.seen('W'))  // if no S or W parameter, the DXC mode gets reset to the user's default

Marlin/src/gcode/feature/L6470/M916-918.cpp

     do {
       // turn the motor(s) both directions
       sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_min), uint16_t(final_feedrate));
-      gcode.process_subcommands_now_P(gcode_string);
+      process_subcommands_now(gcode_string);
 
       sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_max), uint16_t(final_feedrate));
-      gcode.process_subcommands_now_P(gcode_string);
+      process_subcommands_now(gcode_string);
 
       // get the status after the motors have stopped
       planner.synchronize();
     DEBUG_ECHOLNPGM("   OCD threshold : ", (OCD_TH_val + 1) * 375);
 
     sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_min), uint16_t(final_feedrate));
-    gcode.process_subcommands_now_P(gcode_string);
+    process_subcommands_now(gcode_string);
 
     sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_max), uint16_t(final_feedrate));
-    gcode.process_subcommands_now_P(gcode_string);
+    process_subcommands_now(gcode_string);
 
     planner.synchronize();
 
             L64xxManager.set_param(axis_index[j], L6470_KVAL_HOLD, kval_hold);
         }
         DEBUG_ECHOLNPGM(".");
-        gcode.reset_stepper_timeout(); // keep steppers powered
+        reset_stepper_timeout(); // keep steppers powered
         watchdog_refresh();
         safe_delay(5000);
         status_composite_temp = 0;
     DEBUG_ECHOLNPGM("...feedrate = ", current_feedrate);
 
     sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_min), uint16_t(current_feedrate));
-    gcode.process_subcommands_now_P(gcode_string);
+    process_subcommands_now(gcode_string);
 
     sprintf_P(gcode_string, PSTR("G0 %s%03d F%03d"), temp_axis_string, uint16_t(position_max), uint16_t(current_feedrate));
-    gcode.process_subcommands_now_P(gcode_string);
+    process_subcommands_now(gcode_string);
 
     planner.synchronize();
 

Marlin/src/gcode/feature/clean/G12.cpp

 
   #ifdef WIPE_SEQUENCE_COMMANDS
     if (!parser.seen_any()) {
-      gcode.process_subcommands_now_P(PSTR(WIPE_SEQUENCE_COMMANDS));
+      process_subcommands_now(F(WIPE_SEQUENCE_COMMANDS));
       return;
     }
   #endif

Marlin/src/gcode/gcode.cpp

       host_action(PSTR(ACTION_ON_G29_RECOVER));
     #endif
     #ifdef G29_RECOVER_COMMANDS
-      process_subcommands_now_P(PSTR(G29_RECOVER_COMMANDS));
+      process_subcommands_now(F(G29_RECOVER_COMMANDS));
     #endif
   }
 
       host_action(PSTR(ACTION_ON_G29_FAILURE));
     #endif
     #ifdef G29_FAILURE_COMMANDS
-      process_subcommands_now_P(PSTR(G29_FAILURE_COMMANDS));
+      process_subcommands_now(F(G29_FAILURE_COMMANDS));
     #endif
     #if ENABLED(G29_HALT_ON_FAILURE)
       #ifdef ACTION_ON_CANCEL
     TERN_(HOST_PROMPT_SUPPORT, host_action_prompt_end());
 
     #ifdef G29_SUCCESS_COMMANDS
-      process_subcommands_now_P(PSTR(G29_SUCCESS_COMMANDS));
+      process_subcommands_now(F(G29_SUCCESS_COMMANDS));
     #endif
   }
 
  * G-code "macros" to be called from within other G-code handlers.
  */
 
-void GcodeSuite::process_subcommands_now_P(PGM_P pgcode) {
+void GcodeSuite::process_subcommands_now(FSTR_P fgcode) {
+  PGM_P pgcode = FTOP(fgcode);
   char * const saved_cmd = parser.command_ptr;        // Save the parser state
   for (;;) {
     PGM_P const delim = strchr_P(pgcode, '\n');       // Get address of next newline

Marlin/src/gcode/gcode.h

   static void process_next_command();
 
   // Execute G-code in-place, preserving current G-code parameters
-  static void process_subcommands_now_P(PGM_P pgcode);
+  static void process_subcommands_now(FSTR_P fgcode);
   static void process_subcommands_now(char * gcode);
 
   static inline void home_all_axes(const bool keep_leveling=false) {
-    process_subcommands_now_P(keep_leveling ? G28_STR : TERN(CAN_SET_LEVELING_AFTER_G28, PSTR("G28L0"), G28_STR));
+    process_subcommands_now(keep_leveling ? FPSTR(G28_STR) : TERN(CAN_SET_LEVELING_AFTER_G28, F("G28L0"), FPSTR(G28_STR)));
   }
 
   #if EITHER(HAS_AUTO_REPORTING, HOST_KEEPALIVE_FEATURE)

Marlin/src/gcode/motion/G2_G3.cpp

     else {
       #if ENABLED(CNC_WORKSPACE_PLANES)
         char achar, bchar;
-        switch (gcode.workspace_plane) {
+        switch (workspace_plane) {
           default:
           case GcodeSuite::PLANE_XY: achar = 'I'; bchar = 'J'; break;
           case GcodeSuite::PLANE_YZ: achar = 'J'; bchar = 'K'; break;

Marlin/src/gcode/queue.cpp

 
   void GCodeQueue::report_buffer_statistics() {
     SERIAL_ECHOLNPGM("D576"
-      " P:", planner.moves_free(),         " ", -queue.planner_buffer_underruns, " (", queue.max_planner_buffer_empty_duration, ")"
-      " B:", BUFSIZE - ring_buffer.length, " ", -queue.command_buffer_underruns, " (", queue.max_command_buffer_empty_duration, ")"
+      " P:", planner.moves_free(),         " ", -planner_buffer_underruns, " (", max_planner_buffer_empty_duration, ")"
+      " B:", BUFSIZE - ring_buffer.length, " ", -command_buffer_underruns, " (", max_command_buffer_empty_duration, ")"
     );
     command_buffer_underruns = planner_buffer_underruns = 0;
     max_command_buffer_empty_duration = max_planner_buffer_empty_duration = 0;
       NOLESS(max_planner_buffer_empty_duration, planner_buffer_empty_duration); // if it's longer than the currently tracked max duration, replace it
     }
 
-    if (queue.auto_buffer_report_interval && ELAPSED(ms, queue.next_buffer_report_ms)) {
-      queue.next_buffer_report_ms = ms + 1000UL * queue.auto_buffer_report_interval;
+    if (auto_buffer_report_interval && ELAPSED(ms, next_buffer_report_ms)) {
+      next_buffer_report_ms = ms + 1000UL * auto_buffer_report_interval;
       PORT_REDIRECT(SERIAL_BOTH);
       report_buffer_statistics();
       PORT_RESTORE();

Marlin/src/gcode/sd/M1001.cpp

 
   // Report total print time
   const bool long_print = print_job_timer.duration() > 60;
-  if (long_print) gcode.process_subcommands_now_P(PSTR("M31"));
+  if (long_print) process_subcommands_now(F("M31"));
 
   // Stop the print job timer
-  gcode.process_subcommands_now_P(PSTR("M77"));
+  process_subcommands_now(F("M77"));
 
   // Set the progress bar "done" state
   TERN_(LCD_SET_PROGRESS_MANUALLY, ui.set_progress_done());
 
   // Inject SD_FINISHED_RELEASECOMMAND, if any
   #ifdef SD_FINISHED_RELEASECOMMAND
-    gcode.process_subcommands_now_P(PSTR(SD_FINISHED_RELEASECOMMAND));
+    process_subcommands_now(F(SD_FINISHED_RELEASECOMMAND));
   #endif
 
   TERN_(EXTENSIBLE_UI, ExtUI::onPrintFinished());

Marlin/src/lcd/e3v2/enhanced/dwin.cpp

       dtostrf(Y_CENTER, 1, 1, str_2)
     #endif
   );
-  gcode.process_subcommands_now_P(cmd);
+  gcode.process_subcommands_now(cmd);
   planner.synchronize();
   ui.set_status_P(PSTR("Now adjust Z Offset"));
   HMI_AudioFeedback(true);
     dtostrf(X_CENTER, 1, 1, str_1),
     dtostrf(Y_CENTER, 1, 1, str_2)
   );
-  gcode.process_subcommands_now_P(cmd);
+  gcode.process_subcommands_now(cmd);
   planner.synchronize();
   thermalManager.PID_autotune(t, h, HMI_data.PidCycles, true);
 }
 
   #if HAS_ONESTEP_LEVELING
     planner.synchronize();
-    gcode.process_subcommands_now_P(PSTR("M420S0\nG28O"));
+    gcode.process_subcommands_now(F("M420S0\nG28O"));
     planner.synchronize();
     zval = probe.probe_at_point(xpos, ypos, PROBE_PT_STOW);
     sprintf_P(cmd, PSTR(fmt),
 
   void ManualMeshStart(){
     ui.set_status_P(GET_TEXT(MSG_UBL_BUILD_MESH_MENU));
-    gcode.process_subcommands_now_P(PSTR("G28 XYO\nG28 Z\nM211 S0\nG29S1"));
+    gcode.process_subcommands_now(F("G28 XYO\nG28 Z\nM211 S0\nG29S1"));
     planner.synchronize();
     #ifdef MANUAL_PROBE_START_Z
       const uint8_t line = CurrentMenu->line(MMeshMoveZItem->pos);
   void SetMMeshMoveZ() { SetPFloatOnClick(-1, 1, 2, planner.synchronize, LiveMeshMoveZ);}
 
   void ManualMeshContinue(){
-    gcode.process_subcommands_now_P(PSTR("G29S2"));
+    gcode.process_subcommands_now(F("G29S2"));
     planner.synchronize();
     MMeshMoveZItem->draw(CurrentMenu->line(MMeshMoveZItem->pos));
   }

Marlin/src/lcd/e3v2/jyersui/dwin.cpp

 
       void manual_value_update(bool undefined=false) {
         sprintf_P(cmd, PSTR("M421 I%i J%i Z%s %s"), mesh_x, mesh_y, dtostrf(current_position.z, 1, 3, str_1), undefined ? "N" : "");
-        gcode.process_subcommands_now_P(cmd);
+        gcode.process_subcommands_now(cmd);
         planner.synchronize();
       }
 
 
       void manual_value_update() {
         sprintf_P(cmd, PSTR("G29 I%i J%i Z%s"), mesh_x, mesh_y, dtostrf(current_position.z, 1, 3, str_1));
-        gcode.process_subcommands_now_P(cmd);
+        gcode.process_subcommands_now(cmd);
         planner.synchronize();
       }
 
       else {
         CrealityDWIN.Popup_Handler(MoveWait);
         sprintf_P(cmd, PSTR("G0 F300 Z%s"), dtostrf(Z_CLEARANCE_BETWEEN_PROBES, 1, 3, str_1));
-        gcode.process_subcommands_now_P(cmd);
+        gcode.process_subcommands_now(cmd);
         sprintf_P(cmd, PSTR("G42 F4000 I%i J%i"), mesh_x, mesh_y);
-        gcode.process_subcommands_now_P(cmd);
+        gcode.process_subcommands_now(cmd);
         planner.synchronize();
         current_position.z = goto_mesh_value ? Z_VALUES_ARR[mesh_x][mesh_y] : Z_CLEARANCE_BETWEEN_PROBES;
         planner.buffer_line(current_position, homing_feedrate(Z_AXIS), active_extruder);
                   }
                   Popup_Handler(FilChange);
                   sprintf_P(cmd, PSTR("M600 B1 R%i"), thermalManager.temp_hotend[0].target);
-                  gcode.process_subcommands_now_P(cmd);
+                  gcode.process_subcommands_now(cmd);
                 }
               #endif
             }
             Draw_Menu_Item(row, ICON_MoveX, "Home X");
           else {
             Popup_Handler(Home);
-            gcode.process_subcommands_now_P(PSTR("G28 X"));
+            gcode.process_subcommands_now(F("G28 X"));
             planner.synchronize();
             Redraw_Menu();
           }
             Draw_Menu_Item(row, ICON_MoveY, "Home Y");
           else {
             Popup_Handler(Home);
-            gcode.process_subcommands_now_P(PSTR("G28 Y"));
+            gcode.process_subcommands_now(F("G28 Y"));
             planner.synchronize();
             Redraw_Menu();
           }
             Draw_Menu_Item(row, ICON_MoveZ,"Home Z");
           else {
             Popup_Handler(Home);
-            gcode.process_subcommands_now_P(PSTR("G28 Z"));
+            gcode.process_subcommands_now(F("G28 Z"));
             planner.synchronize();
             Redraw_Menu();
           }
           if (draw)
             Draw_Menu_Item(row, ICON_SetHome, "Set Home Position");
           else {
-            gcode.process_subcommands_now_P(PSTR("G92 X0 Y0 Z0"));
+            gcode.process_subcommands_now(F("G92 X0 Y0 Z0"));
             AudioFeedback();
           }
           break;
             if (use_probe) {
               #if HAS_BED_PROBE
                 sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s"), dtostrf(PROBE_X_MIN, 1, 3, str_1), dtostrf(PROBE_Y_MIN, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
                 planner.synchronize();
                 Popup_Handler(ManualProbing);
               #endif
             }
             else {
               sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s\nG0 F300 Z%s"), dtostrf(corner_pos, 1, 3, str_1), dtostrf(corner_pos, 1, 3, str_2), dtostrf(mlev_z_pos, 1, 3, str_3));
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
             if (use_probe) {
               #if HAS_BED_PROBE
                 sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s"), dtostrf(PROBE_X_MIN, 1, 3, str_1), dtostrf(PROBE_Y_MAX, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
                 planner.synchronize();
                 Popup_Handler(ManualProbing);
               #endif
             }
             else {
               sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s\nG0 F300 Z%s"), dtostrf(corner_pos, 1, 3, str_1), dtostrf((Y_BED_SIZE + Y_MIN_POS) - corner_pos, 1, 3, str_2), dtostrf(mlev_z_pos, 1, 3, str_3));
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
             if (use_probe) {
               #if HAS_BED_PROBE
                 sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s"), dtostrf(PROBE_X_MAX, 1, 3, str_1), dtostrf(PROBE_Y_MAX, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
                 planner.synchronize();
                 Popup_Handler(ManualProbing);
               #endif
             }
             else {
               sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s\nG0 F300 Z%s"), dtostrf((X_BED_SIZE + X_MIN_POS) - corner_pos, 1, 3, str_1), dtostrf((Y_BED_SIZE + Y_MIN_POS) - corner_pos, 1, 3, str_2), dtostrf(mlev_z_pos, 1, 3, str_3));
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
             if (use_probe) {
               #if HAS_BED_PROBE
                 sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s"), dtostrf(PROBE_X_MAX, 1, 3, str_1), dtostrf(PROBE_Y_MIN, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
                 planner.synchronize();
                 Popup_Handler(ManualProbing);
               #endif
             }
             else {
               sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s\nG0 F300 Z%s"), dtostrf((X_BED_SIZE + X_MIN_POS) - corner_pos, 1, 3, str_1), dtostrf(corner_pos, 1, 3, str_2), dtostrf(mlev_z_pos, 1, 3, str_3));
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
             if (use_probe) {
               #if HAS_BED_PROBE
                 sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s"), dtostrf(X_MAX_POS / 2.0f - probe.offset.x, 1, 3, str_1), dtostrf(Y_MAX_POS / 2.0f - probe.offset.y, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
                 planner.synchronize();
                 Popup_Handler(ManualProbing);
               #endif
             }
             else {
               sprintf_P(cmd, PSTR("G0 F4000\nG0 Z10\nG0 X%s Y%s\nG0 F300 Z%s"), dtostrf((X_BED_SIZE + X_MIN_POS) / 2.0f, 1, 3, str_1), dtostrf((Y_BED_SIZE + Y_MIN_POS) / 2.0f, 1, 3, str_2), dtostrf(mlev_z_pos, 1, 3, str_3));
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
               Draw_Menu_Item(row, ICON_Homing, "Home Z Axis");
             else {
               Popup_Handler(Home);
-              gcode.process_subcommands_now_P(PSTR("G28 Z"));
+              gcode.process_subcommands_now(F("G28 Z"));
               Popup_Handler(MoveWait);
               #if ENABLED(Z_SAFE_HOMING)
                 planner.synchronize();
                 sprintf_P(cmd, PSTR("G0 F4000 X%s Y%s"), dtostrf(Z_SAFE_HOMING_X_POINT, 1, 3, str_1), dtostrf(Z_SAFE_HOMING_Y_POINT, 1, 3, str_2));
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
               #else
-                gcode.process_subcommands_now_P(PSTR("G0 F4000 X117.5 Y117.5"));
+                gcode.process_subcommands_now(F("G0 F4000 X117.5 Y117.5"));
               #endif
-              gcode.process_subcommands_now_P(PSTR("G0 F300 Z0"));
+              gcode.process_subcommands_now(F("G0 F300 Z0"));
               planner.synchronize();
               Redraw_Menu();
             }
                 #if ENABLED(Z_SAFE_HOMING)
                   planner.synchronize();
                   sprintf_P(cmd, PSTR("G0 F4000 X%s Y%s"), dtostrf(Z_SAFE_HOMING_X_POINT, 1, 3, str_1), dtostrf(Z_SAFE_HOMING_Y_POINT, 1, 3, str_2));
-                  gcode.process_subcommands_now_P(cmd);
+                  gcode.process_subcommands_now(cmd);
                 #else
-                  gcode.process_subcommands_now_P(PSTR("G0 F4000 X117.5 Y117.5"));
+                  gcode.process_subcommands_now(F("G0 F4000 X117.5 Y117.5"));
                 #endif
-                gcode.process_subcommands_now_P(PSTR("G0 F300 Z0"));
+                gcode.process_subcommands_now(F("G0 F300 Z0"));
                 planner.synchronize();
                 Redraw_Menu();
               }
             else {
               if (zoffsetvalue < MAX_Z_OFFSET) {
                 if (liveadjust) {
-                  gcode.process_subcommands_now_P(PSTR("M290 Z0.01"));
+                  gcode.process_subcommands_now(F("M290 Z0.01"));
                   planner.synchronize();
                 }
                 zoffsetvalue += 0.01;
             else {
               if (zoffsetvalue > MIN_Z_OFFSET) {
                 if (liveadjust) {
-                  gcode.process_subcommands_now_P(PSTR("M290 Z-0.01"));
+                  gcode.process_subcommands_now(F("M290 Z-0.01"));
                   planner.synchronize();
                 }
                 zoffsetvalue -= 0.01;
                   thermalManager.wait_for_hotend(0);
                 }
                 Popup_Handler(FilLoad);
-                gcode.process_subcommands_now_P(PSTR("M701"));
+                gcode.process_subcommands_now(F("M701"));
                 planner.synchronize();
                 Redraw_Menu();
               }
                   thermalManager.wait_for_hotend(0);
                 }
                 Popup_Handler(FilLoad, true);
-                gcode.process_subcommands_now_P(PSTR("M702"));
+                gcode.process_subcommands_now(F("M702"));
                 planner.synchronize();
                 Redraw_Menu();
               }
                 }
                 Popup_Handler(FilChange);
                 sprintf_P(cmd, PSTR("M600 B1 R%i"), thermalManager.temp_hotend[0].target);
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
               }
             }
             break;
             else {
               Popup_Handler(PIDWait);
               sprintf_P(cmd, PSTR("M303 E0 C%i S%i U1"), PID_cycles, PID_e_temp);
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
             else {
               Popup_Handler(PIDWait);
               sprintf_P(cmd, PSTR("M303 E-1 C%i S%i U1"), PID_cycles, PID_bed_temp);
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
               planner.synchronize();
               Redraw_Menu();
             }
                 Draw_Menu_Item(row, ICON_StepY, "M48 Probe Test");
               else {
                 sprintf_P(cmd, PSTR("G28O\nM48 X%s Y%s P%i"), dtostrf((X_BED_SIZE + X_MIN_POS) / 2.0f, 1, 3, str_1), dtostrf((Y_BED_SIZE + Y_MIN_POS) / 2.0f, 1, 3, str_2), testcount);
-                gcode.process_subcommands_now_P(cmd);
+                gcode.process_subcommands_now(cmd);
               }
               break;
             case PROBE_TEST_COUNT:
                 Popup_Handler(Home);
                 gcode.home_all_axes(true);
                 Popup_Handler(Level);
-                if (mesh_conf.tilt_grid > 1)
+                if (mesh_conf.tilt_grid > 1) {
                   sprintf_P(cmd, PSTR("G29 J%i"), mesh_conf.tilt_grid);
+                  gcode.process_subcommands_now(cmd);
+                }
                 else
-                  sprintf_P(cmd, PSTR("G29 J"));
-                gcode.process_subcommands_now_P(cmd);
+                  gcode.process_subcommands_now(F("G29 J"));
                 planner.synchronize();
                 Redraw_Menu();
               }
                 #endif
                 #if HAS_BED_PROBE
                   Popup_Handler(Level);
-                  gcode.process_subcommands_now_P(PSTR("G29 P0\nG29 P1"));
-                  gcode.process_subcommands_now_P(PSTR("G29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nM420 S1"));
+                  gcode.process_subcommands_now(F("G29 P0\nG29 P1"));
+                  gcode.process_subcommands_now(F("G29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nG29 P3\nM420 S1"));
                   planner.synchronize();
                   Update_Status("Probed all reachable points");
                   Popup_Handler(SaveLevel);
                 #endif
               #elif HAS_BED_PROBE
                 Popup_Handler(Level);
-                gcode.process_subcommands_now_P(PSTR("G29"));
+                gcode.process_subcommands_now(F("G29"));
                 planner.synchronize();
                 Popup_Handler(SaveLevel);
               #else
                 set_bed_leveling_enabled(false);
                 gridpoint = 1;
                 Popup_Handler(MoveWait);
-                gcode.process_subcommands_now_P(PSTR("G29"));
+                gcode.process_subcommands_now(F("G29"));
                 planner.synchronize();
                 Draw_Menu(ManualMesh);
               #endif
                 Popup_Handler(MeshSlot);
                 break;
               }
-              gcode.process_subcommands_now_P(PSTR("G29 L"));
+              gcode.process_subcommands_now(F("G29 L"));
               planner.synchronize();
               AudioFeedback(true);
             }
                 Popup_Handler(MeshSlot);
                 break;
               }
-              gcode.process_subcommands_now_P(PSTR("G29 S"));
+              gcode.process_subcommands_now(F("G29 S"));
               planner.synchronize();
               AudioFeedback(true);
             }
                 Draw_Menu_Item(row, ICON_ResumeEEPROM, "Convert Mesh to Plane");
               else {
                 if (mesh_conf.create_plane_from_mesh()) break;
-                gcode.process_subcommands_now_P(PSTR("M420 S1"));
+                gcode.process_subcommands_now(F("M420 S1"));
                 planner.synchronize();
                 AudioFeedback(true);
               }
               Draw_Menu_Item(row, ICON_Axis, "Microstep Up");
             else if (Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] < MAX_Z_OFFSET) {
               Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] += 0.01;
-              gcode.process_subcommands_now_P(PSTR("M290 Z0.01"));
+              gcode.process_subcommands_now(F("M290 Z0.01"));
               planner.synchronize();
               current_position.z += 0.01f;
               sync_plan_position();
               Draw_Menu_Item(row, ICON_AxisD, "Microstep Down");
             else if (Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] > MIN_Z_OFFSET) {
               Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] -= 0.01;
-              gcode.process_subcommands_now_P(PSTR("M290 Z-0.01"));
+              gcode.process_subcommands_now(F("M290 Z-0.01"));
               planner.synchronize();
               current_position.z -= 0.01f;
               sync_plan_position();
                 mesh_conf.manual_move();
               }
               else {
-                gcode.process_subcommands_now_P(PSTR("G29 S"));
+                gcode.process_subcommands_now(F("G29 S"));
                 planner.synchronize();
                 AudioFeedback(true);
                 Draw_Menu(Leveling, LEVELING_GET_MESH);
               Draw_Menu_Item(row, ICON_Axis, "Microstep Up");
             else if (Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] < MAX_Z_OFFSET) {
               Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] += 0.01;
-              gcode.process_subcommands_now_P(PSTR("M290 Z0.01"));
+              gcode.process_subcommands_now(F("M290 Z0.01"));
               planner.synchronize();
               current_position.z += 0.01f;
               sync_plan_position();
               Draw_Menu_Item(row, ICON_Axis, "Microstep Down");
             else if (Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] > MIN_Z_OFFSET) {
               Z_VALUES_ARR[mesh_conf.mesh_x][mesh_conf.mesh_y] -= 0.01;
-              gcode.process_subcommands_now_P(PSTR("M290 Z-0.01"));
+              gcode.process_subcommands_now(F("M290 Z-0.01"));
               planner.synchronize();
               current_position.z -= 0.01f;
               sync_plan_position();
             if (draw)
               Draw_Menu_Item(row, ICON_Back, "Cancel");
             else {
-              gcode.process_subcommands_now_P(PSTR("G29 A"));
+              gcode.process_subcommands_now(F("G29 A"));
               planner.synchronize();
               set_bed_leveling_enabled(level_state);
               Draw_Menu(Leveling, LEVELING_GET_MESH);
             }
             else if (gridpoint < GRID_MAX_POINTS) {
               Popup_Handler(MoveWait);
-              gcode.process_subcommands_now_P(PSTR("G29"));
+              gcode.process_subcommands_now(F("G29"));
               planner.synchronize();
               gridpoint++;
               Redraw_Menu();
             }
             else {
-              gcode.process_subcommands_now_P(PSTR("G29"));
+              gcode.process_subcommands_now(F("G29"));
               planner.synchronize();
               AudioFeedback(settings.save());
               Draw_Menu(Leveling, LEVELING_GET_MESH);
             if (draw)
               Draw_Menu_Item(row, ICON_Axis, "Microstep Up");
             else if (current_position.z < MAX_Z_OFFSET) {
-              gcode.process_subcommands_now_P(PSTR("M290 Z0.01"));
+              gcode.process_subcommands_now(F("M290 Z0.01"));
               planner.synchronize();
               current_position.z += 0.01f;
               sync_plan_position();
             if (draw)
               Draw_Menu_Item(row, ICON_AxisD, "Microstep Down");
             else if (current_position.z > MIN_Z_OFFSET) {
-              gcode.process_subcommands_now_P(PSTR("M290 Z-0.01"));
+              gcode.process_subcommands_now(F("M290 Z-0.01"));
               planner.synchronize();
               current_position.z -= 0.01f;
               sync_plan_position();
             if (draw)
               Draw_Menu_Item(row, ICON_Axis, "Z-Offset Up");
             else if (zoffsetvalue < MAX_Z_OFFSET) {
-              gcode.process_subcommands_now_P(PSTR("M290 Z0.01"));
+              gcode.process_subcommands_now(F("M290 Z0.01"));
               zoffsetvalue += 0.01;
               Draw_Float(zoffsetvalue, row - 1, false, 100);
             }
             if (draw)
               Draw_Menu_Item(row, ICON_AxisD, "Z-Offset Down");
             else if (zoffsetvalue > MIN_Z_OFFSET) {
-              gcode.process_subcommands_now_P(PSTR("M290 Z-0.01"));
+              gcode.process_subcommands_now(F("M290 Z-0.01"));
               zoffsetvalue -= 0.01;
               Draw_Float(zoffsetvalue, row - 2, false, 100);
             }
                 case Prepare:
                   Popup_Handler(FilChange);
                   sprintf_P(cmd, PSTR("M600 B1 R%i"), thermalManager.temp_hotend[0].target);
-                  gcode.process_subcommands_now_P(cmd);
+                  gcode.process_subcommands_now(cmd);
                   break;
                 #if ENABLED(FILAMENT_LOAD_UNLOAD_GCODES)
                   case ChangeFilament:
                     switch (last_selection) {
                       case CHANGEFIL_LOAD:
                         Popup_Handler(FilLoad);
-                        gcode.process_subcommands_now_P("M701");
+                        gcode.process_subcommands_now(F("M701"));
                         planner.synchronize();
                         Redraw_Menu(true, true, true);
                         break;
                       case CHANGEFIL_UNLOAD:
                         Popup_Handler(FilLoad, true);
-                        gcode.process_subcommands_now_P("M702");
+                        gcode.process_subcommands_now(F("M702"));
                         planner.synchronize();
                         Redraw_Menu(true, true, true);
                         break;
                       case CHANGEFIL_CHANGE:
                         Popup_Handler(FilChange);
                         sprintf_P(cmd, PSTR("M600 B1 R%i"), thermalManager.temp_hotend[0].target);
-                        gcode.process_subcommands_now_P(cmd);
+                        gcode.process_subcommands_now(cmd);
                         break;
                     }
                     break;
     }
     else if (active_menu == Tune && selection == TUNE_ZOFFSET) {
       sprintf_P(cmd, PSTR("M290 Z%s"), dtostrf((tempvalue / valueunit - zoffsetvalue), 1, 3, str_1));
-      gcode.process_subcommands_now_P(cmd);
+      gcode.process_subcommands_now(cmd);
     }
     if (TERN0(HAS_HOTEND, valuepointer == &thermalManager.temp_hotend[0].pid.Ki) || TERN0(HAS_HEATED_BED, valuepointer == &thermalManager.temp_bed.pid.Ki))
       tempvalue = scalePID_i(tempvalue);
               char cmnd[20];
               #if HAS_HEATED_BED
                 cmnd[sprintf_P(cmnd, PSTR("M140 S%i"), pausebed)] = '\0';
-                gcode.process_subcommands_now_P(PSTR(cmnd));
+                gcode.process_subcommands_now(cmnd);
               #endif
               #if HAS_EXTRUDERS
                 cmnd[sprintf_P(cmnd, PSTR("M109 S%i"), pausetemp)] = '\0';
-                gcode.process_subcommands_now_P(PSTR(cmnd));
+                gcode.process_subcommands_now(cmnd);
               #endif
               TERN_(HAS_FAN, thermalManager.fan_speed[0] = pausefan);
               planner.synchronize();
               }
               Popup_Handler(FilChange);
               sprintf_P(cmd, PSTR("M600 B1 R%i"), thermalManager.temp_hotend[0].target);
-              gcode.process_subcommands_now_P(cmd);
+              gcode.process_subcommands_now(cmd);
             }
           }
           else
         case SaveLevel:
           if (selection == 0) {
             #if ENABLED(AUTO_BED_LEVELING_UBL)
-              gcode.process_subcommands_now_P(PSTR("G29 S"));
+              gcode.process_subcommands_now(F("G29 S"));
               planner.synchronize();
               AudioFeedback(true);
             #else

Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp

   void DGUSScreenHandler::SDPrintingFinished() {
     if (DGUSAutoTurnOff) {
       queue.exhaust();
-      gcode.process_subcommands_now_P(PSTR("M81"));
+      gcode.process_subcommands_now(F("M81"));
     }
     GotoScreen(MKSLCD_SCREEN_PrintDone);
   }

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/spinner_dialog_box.cpp

 }
 
 void SpinnerDialogBox::onIdle() {
-  if (mydata.auto_hide && !commandsInQueue() && TERN1(HOST_KEEPALIVE_FEATURE, GcodeSuite::busy_state == GcodeSuite::NOT_BUSY)) {
+  if (mydata.auto_hide && !commandsInQueue() && TERN1(HOST_KEEPALIVE_FEATURE, gcode.busy_state == gcode.NOT_BUSY)) {
     mydata.auto_hide = false;
     hide();
   }

Marlin/src/lcd/extui/mks_ui/draw_baby_stepping.cpp

   switch (obj->mks_obj_id) {
     case ID_BABY_STEP_X_P:
       sprintf_P(baby_buf, PSTR("M290 X%s"), dtostrf(babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_X_N:
       sprintf_P(baby_buf, PSTR("M290 X%s"), dtostrf(-babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_Y_P:
       sprintf_P(baby_buf, PSTR("M290 Y%s"), dtostrf(babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_Y_N:
       sprintf_P(baby_buf, PSTR("M290 Y%s"), dtostrf(-babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_Z_P:
       sprintf_P(baby_buf, PSTR("M290 Z%s"), dtostrf(babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_Z_N:
       sprintf_P(baby_buf, PSTR("M290 Z%s"), dtostrf(-babystep_dist, 1, 3, str_1));
-      gcode.process_subcommands_now_P(PSTR(baby_buf));
+      gcode.process_subcommands_now(F(baby_buf));
       has_adjust_z = 1;
       break;
     case ID_BABY_STEP_DIST:

Marlin/src/lcd/extui/mks_ui/draw_filament_change.cpp

     case ID_FILAMNT_RETURN:
       #if HAS_MULTI_EXTRUDER
         if (uiCfg.print_state != IDLE && uiCfg.print_state != REPRINTED)
-          gcode.process_subcommands_now_P(uiCfg.extruderIndexBak == 1 ? PSTR("T1") : PSTR("T0"));
+          gcode.process_subcommands_now(uiCfg.extruderIndexBak == 1 ? F("T1") : F("T0"));
       #endif
       feedrate_mm_s = (float)uiCfg.moveSpeed_bak;
       if (uiCfg.print_state == PAUSED)

Marlin/src/lcd/extui/mks_ui/draw_number_key.cpp

     case z_sensitivity: TERN_(Z_SENSORLESS, stepperZ.homing_threshold(atoi(key_value))); break;
     case z2_sensitivity: TERN_(Z2_SENSORLESS, stepperZ2.homing_threshold(atoi(key_value))); break;
   }
-  gcode.process_subcommands_now_P(PSTR("M500"));
+  gcode.process_subcommands_now(F("M500"));
 }
 
 static void event_handler(lv_obj_t *obj, lv_event_t event) {

Marlin/src/lcd/extui/mks_ui/draw_printing.cpp

 
         #if HAS_SUICIDE
           if (gCfgItems.finish_power_off) {
-            gcode.process_subcommands_now_P(PSTR("M1001"));
+            gcode.process_subcommands_now(F("M1001"));
             queue.inject_P(PSTR("M81"));
             marlin_state = MF_RUNNING;
           }

Marlin/src/lcd/extui/mks_ui/printer_operation.cpp

         uiCfg.waitEndMoves = 0;
         planner.synchronize();
 
-        gcode.process_subcommands_now_P(PSTR("M25"));
+        gcode.process_subcommands_now(F("M25"));
 
         // save the position
         uiCfg.current_x_position_bak = current_position.x;
         sprintf_P(public_buf_m, PSTR("G1 Z%s"), dtostrf(uiCfg.current_z_position_bak, 1, 1, str_1));
         gcode.process_subcommands_now(public_buf_m);
       }
-      gcode.process_subcommands_now_P(M24_STR);
+      gcode.process_subcommands_now(FPSTR(M24_STR));
       uiCfg.print_state = WORKING;
       start_print_time();
 

Marlin/src/module/tool_change.cpp

     if (!no_move) {
       #ifdef EVENT_GCODE_TOOLCHANGE_T0
         if (new_tool == 0)
-          gcode.process_subcommands_now_P(PSTR(EVENT_GCODE_TOOLCHANGE_T0));
+          gcode.process_subcommands_now(F(EVENT_GCODE_TOOLCHANGE_T0));
       #endif
 
       #ifdef EVENT_GCODE_TOOLCHANGE_T1
         if (new_tool == 1)
-          gcode.process_subcommands_now_P(PSTR(EVENT_GCODE_TOOLCHANGE_T1));
+          gcode.process_subcommands_now(F(EVENT_GCODE_TOOLCHANGE_T1));
       #endif
 
       #ifdef EVENT_GCODE_AFTER_TOOLCHANGE
         if (TERN1(DUAL_X_CARRIAGE, dual_x_carriage_mode == DXC_AUTO_PARK_MODE))
-          gcode.process_subcommands_now_P(PSTR(EVENT_GCODE_AFTER_TOOLCHANGE));
+          gcode.process_subcommands_now(F(EVENT_GCODE_AFTER_TOOLCHANGE));
       #endif
     }