Reference op with variable name

Marlin/Marlin_main.cpp

     KEEPALIVE_STATE(IN_HANDLER);
   }
 
-  static void resume_print(const float& load_length = 0, const float& initial_extrude_length = 0, int8_t max_beep_count = 0) {
+  static void resume_print(const float &load_length = 0, const float &initial_extrude_length = 0, int8_t max_beep_count = 0) {
     bool nozzle_timed_out = false;
 
     if (!move_away_flag) return;

Marlin/SdBaseFile.cpp

 //------------------------------------------------------------------------------
 // suppress cpplint warnings with NOLINT comment
 #if ALLOW_DEPRECATED_FUNCTIONS && !defined(DOXYGEN)
-  void (*SdBaseFile::oldDateTime_)(uint16_t& date, uint16_t& time) = 0;  // NOLINT
+  void (*SdBaseFile::oldDateTime_)(uint16_t &date, uint16_t &time) = 0;  // NOLINT
 #endif  // ALLOW_DEPRECATED_FUNCTIONS
 
 

Marlin/SdBaseFile.h

    * \param[in] dateTime The user's call back function.
    */
   static void dateTimeCallback(
-    void (*dateTime)(uint16_t& date, uint16_t& time)) {  // NOLINT
+    void (*dateTime)(uint16_t &date, uint16_t &time)) {  // NOLINT
     oldDateTime_ = dateTime;
     dateTime_ = dateTime ? oldToNew : 0;
   }
   //------------------------------------------------------------------------------
   // rest are private
  private:
-  static void (*oldDateTime_)(uint16_t& date, uint16_t& time);  // NOLINT
+  static void (*oldDateTime_)(uint16_t &date, uint16_t &time);  // NOLINT
   static void oldToNew(uint16_t* date, uint16_t* time) {
     uint16_t d;
     uint16_t t;

Marlin/planner.cpp

 /**
  * Setters for planner position (also setting stepper position).
  */
-void Planner::set_position_mm(const AxisEnum axis, const float& v) {
+void Planner::set_position_mm(const AxisEnum axis, const float &v) {
   #if ENABLED(DISTINCT_E_FACTORS)
     const uint8_t axis_index = axis + (axis == E_AXIS ? active_extruder : 0);
     last_extruder = active_extruder;

Marlin/ubl_motion.cpp

       float seg_dest[XYZE];  // per-segment destination, initialize to first segment
       LOOP_XYZE(i) seg_dest[i] = current_position[i] + segment_distance[i];
 
-      const float& dx_seg = segment_distance[X_AXIS];  // alias for clarity
-      const float& dy_seg = segment_distance[Y_AXIS];
+      const float &dx_seg = segment_distance[X_AXIS];  // alias for clarity
+      const float &dy_seg = segment_distance[Y_AXIS];
 
       float rx = RAW_X_POSITION(seg_dest[X_AXIS]),  // assume raw vs logical coordinates shifted but not scaled.
             ry = RAW_Y_POSITION(seg_dest[Y_AXIS]);

Marlin/utility.cpp

   #define MINUSOR(n, alt) (n >= 0 ? (alt) : (n = -n, '-'))
 
   // Convert unsigned int to string with 12 format
-  char* itostr2(const uint8_t& xx) {
+  char* itostr2(const uint8_t &xx) {
     conv[5] = DIGIMOD(xx, 10);
     conv[6] = DIGIMOD(xx, 1);
     return &conv[5];
   }
 
   // Convert signed int to rj string with 123 or -12 format
-  char* itostr3(const int& x) {
+  char* itostr3(const int &x) {
     int xx = x;
     conv[4] = MINUSOR(xx, RJDIGIT(xx, 100));
     conv[5] = RJDIGIT(xx, 10);
   }
 
   // Convert unsigned int to lj string with 123 format
-  char* itostr3left(const int& xx) {
+  char* itostr3left(const int &xx) {
     char *str = &conv[6];
     *str = DIGIMOD(xx, 1);
     if (xx >= 10) {
   }
 
   // Convert signed int to rj string with 1234, _123, -123, _-12, or __-1 format
-  char *itostr4sign(const int& x) {
+  char *itostr4sign(const int &x) {
     const bool neg = x < 0;
     const int xx = neg ? -x : x;
     if (x >= 1000) {
   }
 
   // Convert unsigned float to string with 1.23 format
-  char* ftostr12ns(const float& x) {
+  char* ftostr12ns(const float &x) {
     const long xx = (x < 0 ? -x : x) * 100;
     conv[3] = DIGIMOD(xx, 100);
     conv[4] = '.';
   }
 
   // Convert signed float to fixed-length string with 023.45 / -23.45 format
-  char *ftostr32(const float& x) {
+  char *ftostr32(const float &x) {
     long xx = x * 100;
     conv[1] = MINUSOR(xx, DIGIMOD(xx, 10000));
     conv[2] = DIGIMOD(xx, 1000);
   #if ENABLED(LCD_DECIMAL_SMALL_XY)
 
     // Convert float to rj string with 1234, _123, -123, _-12, 12.3, _1.2, or -1.2 format
-    char *ftostr4sign(const float& fx) {
+    char *ftostr4sign(const float &fx) {
       const int x = fx * 10;
       if (!WITHIN(x, -99, 999)) return itostr4sign((int)fx);
       const bool neg = x < 0;
   #endif // LCD_DECIMAL_SMALL_XY
 
   // Convert float to fixed-length string with +123.4 / -123.4 format
-  char* ftostr41sign(const float& x) {
+  char* ftostr41sign(const float &x) {
     int xx = x * 10;
     conv[1] = MINUSOR(xx, '+');
     conv[2] = DIGIMOD(xx, 1000);
   }
 
   // Convert signed float to string (6 digit) with -1.234 / _0.000 / +1.234 format
-  char* ftostr43sign(const float& x, char plus/*=' '*/) {
+  char* ftostr43sign(const float &x, char plus/*=' '*/) {
     long xx = x * 1000;
     conv[1] = xx ? MINUSOR(xx, plus) : ' ';
     conv[2] = DIGIMOD(xx, 1000);
   }
 
   // Convert unsigned float to rj string with 12345 format
-  char* ftostr5rj(const float& x) {
+  char* ftostr5rj(const float &x) {
     const long xx = x < 0 ? -x : x;
     conv[2] = RJDIGIT(xx, 10000);
     conv[3] = RJDIGIT(xx, 1000);
   }
 
   // Convert signed float to string with +1234.5 format
-  char* ftostr51sign(const float& x) {
+  char* ftostr51sign(const float &x) {
     long xx = x * 10;
     conv[0] = MINUSOR(xx, '+');
     conv[1] = DIGIMOD(xx, 10000);
   }
 
   // Convert signed float to string with +123.45 format
-  char* ftostr52sign(const float& x) {
+  char* ftostr52sign(const float &x) {
     long xx = x * 100;
     conv[0] = MINUSOR(xx, '+');
     conv[1] = DIGIMOD(xx, 10000);
   }
 
   // Convert unsigned float to string with 1234.56 format omitting trailing zeros
-  char* ftostr62rj(const float& x) {
+  char* ftostr62rj(const float &x) {
     const long xx = (x < 0 ? -x : x) * 100;
     conv[0] = RJDIGIT(xx, 100000);
     conv[1] = RJDIGIT(xx, 10000);
   }
 
   // Convert signed float to space-padded string with -_23.4_ format
-  char* ftostr52sp(const float& x) {
+  char* ftostr52sp(const float &x) {
     long xx = x * 100;
     uint8_t dig;
     conv[1] = MINUSOR(xx, RJDIGIT(xx, 10000));

Marlin/utility.h

 #if ENABLED(ULTRA_LCD)
 
   // Convert unsigned int to string with 12 format
-  char* itostr2(const uint8_t& x);
+  char* itostr2(const uint8_t &x);
 
   // Convert signed int to rj string with 123 or -12 format
-  char* itostr3(const int& x);
+  char* itostr3(const int &x);
 
   // Convert unsigned int to lj string with 123 format
-  char* itostr3left(const int& xx);
+  char* itostr3left(const int &xx);
 
   // Convert signed int to rj string with _123, -123, _-12, or __-1 format
-  char *itostr4sign(const int& x);
+  char *itostr4sign(const int &x);
 
   // Convert unsigned float to string with 1.23 format
-  char* ftostr12ns(const float& x);
+  char* ftostr12ns(const float &x);
 
   // Convert signed float to fixed-length string with 023.45 / -23.45 format
-  char *ftostr32(const float& x);
+  char *ftostr32(const float &x);
 
   // Convert float to fixed-length string with +123.4 / -123.4 format
-  char* ftostr41sign(const float& x);
+  char* ftostr41sign(const float &x);
 
   // Convert signed float to string (6 digit) with -1.234 / _0.000 / +1.234 format
-  char* ftostr43sign(const float& x, char plus=' ');
+  char* ftostr43sign(const float &x, char plus=' ');
 
   // Convert unsigned float to rj string with 12345 format
-  char* ftostr5rj(const float& x);
+  char* ftostr5rj(const float &x);
 
   // Convert signed float to string with +1234.5 format
-  char* ftostr51sign(const float& x);
+  char* ftostr51sign(const float &x);
 
   // Convert signed float to space-padded string with -_23.4_ format
-  char* ftostr52sp(const float& x);
+  char* ftostr52sp(const float &x);
 
   // Convert signed float to string with +123.45 format
-  char* ftostr52sign(const float& x);
+  char* ftostr52sign(const float &x);
 
   // Convert unsigned float to string with 1234.56 format omitting trailing zeros
-  char* ftostr62rj(const float& x);
+  char* ftostr62rj(const float &x);
 
   // Convert float to rj string with 123 or -12 format
-  FORCE_INLINE char *ftostr3(const float& x) { return itostr3((int)x); }
+  FORCE_INLINE char *ftostr3(const float &x) { return itostr3((int)x); }
 
   #if ENABLED(LCD_DECIMAL_SMALL_XY)
     // Convert float to rj string with 1234, _123, 12.3, _1.2, -123, _-12, or -1.2 format
-    char *ftostr4sign(const float& fx);
+    char *ftostr4sign(const float &fx);
   #else
     // Convert float to rj string with 1234, _123, -123, __12, _-12, ___1, or __-1 format
-    FORCE_INLINE char *ftostr4sign(const float& x) { return itostr4sign((int)x); }
+    FORCE_INLINE char *ftostr4sign(const float &x) { return itostr4sign((int)x); }
   #endif
 
 #endif // ULTRA_LCD

Marlin/vector_3.h

 };
 
 
-void apply_rotation_xyz(matrix_3x3 rotationMatrix, float& x, float& y, float& z);
+void apply_rotation_xyz(matrix_3x3 rotationMatrix, float &x, float &y, float &z);
 
 #endif // HAS_ABL
 #endif // VECTOR_3_H