Merge pull request #11542 from thinkyhead/bf2_misc_fixes_aug_6

Followup persistent store with heading, const

Marlin/src/HAL/HAL_AVR/persistent_store_eeprom.cpp

+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (C) 2016, 2017 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/>.
+ *
+ */
 #ifdef __AVR__
 
 #include "../../inc/MarlinConfig.h"
   return false;  // always assume success for AVR's
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS
 #endif // __AVR__

Marlin/src/HAL/HAL_DUE/persistent_store_eeprom.cpp

+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
+ *
+ * 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/>.
+ *
+ */
 #ifdef ARDUINO_ARCH_SAM
 
 #include "../persistent_store_api.h"
   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS
 #endif // ARDUINO_ARCH_SAM

Marlin/src/HAL/HAL_LPC1768/persistent_store_sdcard.cpp

 /**
  * Marlin 3D Printer Firmware
- * Copyright (C) 2016, 2017 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
  *
- * Based on Sprinter and grbl.
- * Copyright (C) 2011 Camiel Gubbels / Erik van der Zalm
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
  *
  * 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
 //    FR_INVALID_PARAMETER     /* (19) Given parameter is invalid */
 //  } FRESULT;
 
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
-  if(!eeprom_file_open) return true;
+bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
+  if (!eeprom_file_open) return true;
   FRESULT s;
   UINT bytes_written = 0;
 
    return s;
   }
 
-  s = f_write(&eeprom_file, (void *)value, size, &bytes_written);
+  s = f_write(&eeprom_file, (void*)value, size, &bytes_written);
   if (s) {
    SERIAL_PROTOCOLPAIR(" write_data(", pos);         // This extra chit-chat goes away soon.  But it is helpful
    SERIAL_PROTOCOLPAIR(",", (int)value);            // right now to see errors that are happening in the
   return (bytes_written != size);  // return true for any error
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
-  if(!eeprom_file_open) return true;
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
+  if (!eeprom_file_open) return true;
   UINT bytes_read = 0;
   FRESULT s;
   s = f_lseek(&eeprom_file, pos);
+
   if (s) {
-   SERIAL_PROTOCOLPAIR(" read_data(", pos);          // This extra chit-chat goes away soon.  But it is helpful
-   SERIAL_PROTOCOLPAIR(",", (int)value);            // right now to see errors that are happening in the
-   SERIAL_PROTOCOLPAIR(",", size);             // read_data() and write_data() functions
+   SERIAL_PROTOCOLPAIR(" read_data(", pos);         // This extra chit-chat goes away soon.  But it is helpful
+   SERIAL_PROTOCOLCHAR(',');
+   SERIAL_PROTOCOL((int)value);                     // right now to see errors that are happening in the
+   SERIAL_PROTOCOLCHAR(',');
+   SERIAL_PROTOCOL(size);                           // read_data() and write_data() functions
    SERIAL_PROTOCOLLNPGM("...)");
    SERIAL_PROTOCOLLNPAIR(" f_lseek()=", (int)s);
    return true;
   }
+
   if (writing) {
-    s = f_read(&eeprom_file, (void *)value, size, &bytes_read);
+    s = f_read(&eeprom_file, (void*)value, size, &bytes_read);
     crc16(crc, value, size);
   }
   else {
     uint8_t temp[size];
-    s = f_read(&eeprom_file, (void *)temp, size, &bytes_read);
+    s = f_read(&eeprom_file, (void*)temp, size, &bytes_read);
     crc16(crc, temp, size);
   }
+
   if (s) {
    SERIAL_PROTOCOLPAIR(" read_data(", pos);         // This extra chit-chat goes away soon.  But it is helpful
-   SERIAL_PROTOCOLPAIR(",", (int)value);           // right now to see errors that are happening in the
-   SERIAL_PROTOCOLPAIR(",", size);            // read_data() and write_data() functions
+   SERIAL_PROTOCOLCHAR(',');
+   SERIAL_PROTOCOL((int)value);                     // right now to see errors that are happening in the
+   SERIAL_PROTOCOLCHAR(',');
+   SERIAL_PROTOCOL(size);                           // read_data() and write_data() functions
    SERIAL_PROTOCOLLNPGM("...)");
    SERIAL_PROTOCOLLNPAIR(" f_write()=", (int)s);
    SERIAL_PROTOCOLPAIR(" size=", size);
    SERIAL_PROTOCOLLNPAIR("\n bytes_read=",  bytes_read);
    return true;
   }
+
   pos = pos + size;
   return bytes_read != size;  // return true for any error
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return 4096; //4KiB of Emulated EEPROM
-}
+const size_t PersistentStore::capacity() { return 4096; } // 4KiB of Emulated EEPROM
 
 #endif // EEPROM_SETTINGS
 #endif // TARGET_LPC1768

Marlin/src/HAL/HAL_STM32F1/persistent_store_flash.cpp

   return true;
 }
 
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
   FLASH_Status status;
 
   if (firstWrite) {
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
   for (uint16_t i = 0; i < size; i++) {
     byte* accessPoint = (byte*)(pageBase + pos + i);
     uint8_t c = *accessPoint;
   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
-
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS && EEPROM FLASH
 #endif // __STM32F1__

Marlin/src/HAL/HAL_STM32F1/persistent_store_sdcard.cpp

   return (bytes_written == HAL_STM32F1_EEPROM_SIZE);
 }
 
-bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc) {
+bool PersistentStore::write_data(int &pos, const uint8_t *value, const size_t size, uint16_t *crc) {
   for (int i = 0; i < size; i++)
     HAL_STM32F1_eeprom_content[pos + i] = value[i];
   crc16(crc, value, size);
   return false;
 }
 
-bool PersistentStore::read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing/*=true*/) {
+bool PersistentStore::read_data(int &pos, uint8_t* value, const size_t size, uint16_t *crc, const bool writing/*=true*/) {
   for (int i = 0; i < size; i++) {
     uint8_t c = HAL_STM32F1_eeprom_content[pos + i];
     if (writing) value[i] = c;
   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return HAL_STM32F1_EEPROM_SIZE;
-}
+const size_t PersistentStore::capacity() { return HAL_STM32F1_EEPROM_SIZE; }
 
 #endif // EEPROM_SETTINGS
 

Marlin/src/HAL/HAL_STM32F4/persistent_store_eeprom.cpp

   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS
 #endif // STM32F4 || STM32F4xx

Marlin/src/HAL/HAL_STM32F7/persistent_store_eeprom.cpp

  *
  */
 
-
 #ifdef STM32F7
 
 #include "../../inc/MarlinConfig.h"
   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS
 #endif // STM32F7

Marlin/src/HAL/HAL_TEENSY35_36/persistent_store_eeprom.cpp

+/**
+ * Marlin 3D Printer Firmware
+ *
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
+ *
+ * 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/>.
+ *
+ */
+
 #if defined(__MK64FX512__) || defined(__MK66FX1M0__)
 
 #include "../../inc/MarlinConfig.h"
   return false;
 }
 
-bool PersistentStore::write_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return write_data(data_pos, value, size, &crc);
-}
-
-bool PersistentStore::read_data(const int pos, uint8_t* value, size_t size) {
-  int data_pos = pos;
-  uint16_t crc = 0;
-  return read_data(data_pos, value, size, &crc);
-}
-
-const size_t PersistentStore::capacity() {
-  return E2END + 1;
-}
+const size_t PersistentStore::capacity() { return E2END + 1; }
 
 #endif // EEPROM_SETTINGS
 #endif // __MK64FX512__ || __MK66FX1M0__

Marlin/src/HAL/persistent_store_api.cpp

 /**
  * 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
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
  *
  * 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

Marlin/src/HAL/persistent_store_api.h

 /**
  * 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
+ * Copyright (C) 2016 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ * Copyright (c) 2016 Bob Cousins bobcousins42@googlemail.com
+ * Copyright (c) 2015-2016 Nico Tonnhofer wurstnase.reprap@gmail.com
+ * Copyright (c) 2016 Victor Perez victor_pv@hotmail.com
  *
  * 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
   static bool access_finish();
   static bool write_data(int &pos, const uint8_t *value, size_t size, uint16_t *crc);
   static bool read_data(int &pos, uint8_t* value, size_t size, uint16_t *crc, const bool writing=true);
-  static bool write_data(const int pos, uint8_t* value, size_t size);
-  static bool read_data(const int pos, uint8_t* value, size_t size);
   static const size_t capacity();
+
+  static inline bool write_data(const int pos, uint8_t* value, const size_t size) {
+    int data_pos = pos;
+    uint16_t crc = 0;
+    return write_data(data_pos, value, size, &crc);
+  }
+
+  static inline bool read_data(const int pos, uint8_t* value, const size_t size) {
+    int data_pos = pos;
+    uint16_t crc = 0;
+    return read_data(data_pos, value, size, &crc);
+  }
 };
 
 extern PersistentStore persistentStore;

Marlin/src/feature/bedlevel/ubl/ubl.h

      * z_correction_for_x_on_horizontal_mesh_line is an optimization for
      * the case where the printer is making a vertical line that only crosses horizontal mesh lines.
      */
-    inline static float z_correction_for_x_on_horizontal_mesh_line(const float &rx0, const int x1_i, const int yi) {
+    static inline float z_correction_for_x_on_horizontal_mesh_line(const float &rx0, const int x1_i, const int yi) {
       if (!WITHIN(x1_i, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(yi, 0, GRID_MAX_POINTS_Y - 1)) {
         #if ENABLED(DEBUG_LEVELING_FEATURE)
           if (DEBUGGING(LEVELING)) {
     //
     // See comments above for z_correction_for_x_on_horizontal_mesh_line
     //
-    inline static float z_correction_for_y_on_vertical_mesh_line(const float &ry0, const int xi, const int y1_i) {
+    static inline float z_correction_for_y_on_vertical_mesh_line(const float &ry0, const int xi, const int y1_i) {
       if (!WITHIN(xi, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(y1_i, 0, GRID_MAX_POINTS_Y - 1)) {
         #if ENABLED(DEBUG_LEVELING_FEATURE)
           if (DEBUGGING(LEVELING)) {
       static void line_to_destination_cartesian(const float &fr, const uint8_t e);
     #endif
 
-    inline static bool mesh_is_valid() {
+    static inline bool mesh_is_valid() {
       for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
         for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
           if (isnan(z_values[x][y])) return false;

Marlin/src/gcode/parser.h

   FORCE_INLINE static bool has_value() { return value_ptr != NULL; }
 
   // Seen a parameter with a value
-  inline static bool seenval(const char c) { return seen(c) && has_value(); }
+  static inline bool seenval(const char c) { return seen(c) && has_value(); }
 
   // Float removes 'E' to prevent scientific notation interpretation
-  inline static float value_float() {
+  static inline float value_float() {
     if (value_ptr) {
       char *e = value_ptr;
       for (;;) {
   }
 
   // Code value as a long or ulong
-  inline static int32_t value_long() { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
-  inline static uint32_t value_ulong() { return value_ptr ? strtoul(value_ptr, NULL, 10) : 0UL; }
+  static inline int32_t value_long() { return value_ptr ? strtol(value_ptr, NULL, 10) : 0L; }
+  static inline uint32_t 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(); }
   // Reduce to fewer bits
   FORCE_INLINE static int16_t value_int() { return (int16_t)value_long(); }
   FORCE_INLINE static uint16_t value_ushort() { return (uint16_t)value_long(); }
-  inline static uint8_t value_byte() { return (uint8_t)constrain(value_long(), 0, 255); }
+  static inline 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(); }
+  static inline bool value_bool() { return !has_value() || !!value_byte(); }
 
   // Units modes: Inches, Fahrenheit, Kelvin
 
     // Init linear units by constructor
     GCodeParser() { set_input_linear_units(LINEARUNIT_MM); }
 
-    inline static void set_input_linear_units(const LinearUnit units) {
+    static inline void set_input_linear_units(const LinearUnit units) {
       switch (units) {
         case LINEARUNIT_INCH:
           linear_unit_factor = 25.4f;
       volumetric_unit_factor = POW(linear_unit_factor, 3);
     }
 
-    inline static float axis_unit_factor(const AxisEnum axis) {
+    static inline 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); }
+    static inline float value_linear_units()                     { return value_float() * linear_unit_factor; }
+    static inline float value_axis_units(const AxisEnum axis)    { return value_float() * axis_unit_factor(axis); }
+    static inline float value_per_axis_unit(const AxisEnum axis) { return value_float() / axis_unit_factor(axis); }
 
   #else
 
 
   #if ENABLED(TEMPERATURE_UNITS_SUPPORT)
 
-    inline static void set_input_temp_units(TempUnit units) { input_temp_units = units; }
+    static inline void set_input_temp_units(TempUnit units) { input_temp_units = units; }
 
     #if ENABLED(ULTIPANEL) && DISABLED(DISABLE_M503)
 
       FORCE_INLINE static const 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) {
+      static inline float to_temp_units(const float &f) {
         switch (input_temp_units) {
           case TEMPUNIT_F:
             return f * 0.5555555556f + 32;
 
     #endif // ULTIPANEL && !DISABLE_M503
 
-    inline static float value_celsius() {
+    static inline float value_celsius() {
       const float f = value_float();
       switch (input_temp_units) {
         case TEMPUNIT_F:
       }
     }
 
-    inline static float value_celsius_diff() {
+    static inline float value_celsius_diff() {
       switch (input_temp_units) {
         case TEMPUNIT_F:
           return value_float() * 0.5555555556f;

Marlin/src/libs/buzzer.h

      * @brief Resets the state of the class
      * @details Brings the class state to a known one.
      */
-    inline static void reset() {
+    static inline void reset() {
       off();
       state.endtime = 0;
     }

Marlin/src/module/planner.h

        *  Returns 1.0 if planner.z_fade_height is 0.0.
        *  Returns 0.0 if Z is past the specified 'Fade Height'.
        */
-      inline static float fade_scaling_factor_for_z(const float &rz) {
+      static inline float fade_scaling_factor_for_z(const float &rz) {
         static float z_fade_factor = 1;
         if (z_fade_height) {
           if (rz >= z_fade_height) return 0;

Marlin/src/module/planner_bezier.cpp

 #define SIGMA 0.1f
 
 // Compute the linear interpolation between two real numbers.
-inline static float interp(float a, float b, float t) { return (1 - t) * a + t * b; }
+static inline float interp(const float &a, const float &b, const float &t) { return (1 - t) * a + t * b; }
 
 /**
  * Compute a Bézier curve using the De Casteljau's algorithm (see
  * easy to code and has good numerical stability (very important,
  * since Arudino works with limited precision real numbers).
  */
-inline static float eval_bezier(float a, float b, float c, float d, float t) {
-  float iab = interp(a, b, t);
-  float ibc = interp(b, c, t);
-  float icd = interp(c, d, t);
-  float iabc = interp(iab, ibc, t);
-  float ibcd = interp(ibc, icd, t);
-  float iabcd = interp(iabc, ibcd, t);
-  return iabcd;
+static inline float eval_bezier(const float &a, const float &b, const float &c, const float &d, const float &t) {
+  const float iab = interp(a, b, t),
+              ibc = interp(b, c, t),
+              icd = interp(c, d, t),
+              iabc = interp(iab, ibc, t),
+              ibcd = interp(ibc, icd, t);
+  return interp(iabc, ibcd, t);
 }
 
 /**
  * We approximate Euclidean distance with the sum of the coordinates
  * offset (so-called "norm 1"), which is quicker to compute.
  */
-inline static float dist1(float x1, float y1, float x2, float y2) { return ABS(x1 - x2) + ABS(y1 - y2); }
+static inline float dist1(const float &x1, const float &y1, const float &x2, const float &y2) { return ABS(x1 - x2) + ABS(y1 - y2); }
 
 /**
  * The algorithm for computing the step is loosely based on the one in Kig

Marlin/src/module/stepper.h

     #endif
 
     // Set the current position in steps
-    inline static void set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) {
+    static inline void set_position(const int32_t &a, const int32_t &b, const int32_t &c, const int32_t &e) {
       planner.synchronize();
       const bool was_enabled = STEPPER_ISR_ENABLED();
       if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
       if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
     }
 
-    inline static void set_position(const AxisEnum a, const int32_t &v) {
+    static inline void set_position(const AxisEnum a, const int32_t &v) {
       planner.synchronize();
 
       #ifdef __AVR__