Clean up excess whitespace, comment formatting

Marlin/Marlin_main.cpp

       safe_delay(BLTOUCH_DELAY);
     }
 
-    // 
+    //
     // The BL-Touch probes have a HAL effect sensor.  The high currents switching
     // on and off cause big magnetic fields that can affect the repeatability of the
     // sensor.  So, for BL-Touch probes, we turn off the heaters during the actual probe.
     void turn_heaters_on_or_off_for_bltouch(const bool deploy) {
       static int8_t bltouch_recursion_cnt=0;
       static millis_t last_emi_protection=0;
-      static float temps_at_entry[HOTENDS]; 
+      static float temps_at_entry[HOTENDS];
       #if HAS_TEMP_BED
         static float bed_temp_at_entry;
       #endif
       if (deploy) {
         bltouch_recursion_cnt++;
         last_emi_protection = millis();
-        HOTEND_LOOP() temps_at_entry[e] = thermalManager.degTargetHotend(e);        // save the current target temperatures 
+        HOTEND_LOOP() temps_at_entry[e] = thermalManager.degTargetHotend(e);        // save the current target temperatures
         HOTEND_LOOP() thermalManager.setTargetHotend(0, e);                         // so we know what to restore them to.
 
         #if HAS_TEMP_BED
           bed_temp_at_entry = thermalManager.degTargetBed();
           thermalManager.setTargetBed(0.0);
         #endif
-      } 
+      }
       else {
         bltouch_recursion_cnt--;                                                    // the heaters are only turned back on
 	if (bltouch_recursion_cnt==0 && ((last_emi_protection+20000L)>millis())) {  // if everything is perfect.  It is expected
-          HOTEND_LOOP() thermalManager.setTargetHotend(temps_at_entry[e], e);       // that the bltouch_recursion_cnt is zero and 
-          #if HAS_TEMP_BED                                                          // that the heaters were shut off less than 
+          HOTEND_LOOP() thermalManager.setTargetHotend(temps_at_entry[e], e);       // that the bltouch_recursion_cnt is zero and
+          #if HAS_TEMP_BED                                                          // that the heaters were shut off less than
             thermalManager.setTargetBed(bed_temp_at_entry);                         // 20 seconds ago
           #endif
         }
         turn_heaters_on_or_off_for_bltouch(deploy);
       #endif
       if (deploy && TEST_BLTOUCH()) {      // If BL-Touch says it's triggered
-        bltouch_command(BLTOUCH_RESET);    // try to reset it.
+        bltouch_command(BLTOUCH_RESET);    //  try to reset it.
         bltouch_command(BLTOUCH_DEPLOY);   // Also needs to deploy and stow to
-        bltouch_command(BLTOUCH_STOW);     // clear the triggered condition.
-        safe_delay(1500);                  // wait for internal self test to complete
-                                           //   measured completion time was 0.65 seconds
-                                           //   after reset, deploy & stow sequence
+        bltouch_command(BLTOUCH_STOW);     //  clear the triggered condition.
+        safe_delay(1500);                  // Wait for internal self-test to complete.
+                                           //  (Measured completion time was 0.65 seconds
+                                           //   after reset, deploy, and stow sequence)
         if (TEST_BLTOUCH()) {              // If it still claims to be triggered...
           SERIAL_ERROR_START;
           SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH);
     return current_position[Z_AXIS] + zprobe_zoffset;
   }
 
-  //
-  // - Move to the given XY
-  // - Deploy the probe, if not already deployed
-  // - Probe the bed, get the Z position
-  // - Depending on the 'stow' flag
-  //   - Stow the probe, or
-  //   - Raise to the BETWEEN height
-  // - Return the probed Z position
-  //
+  /**
+   * - Move to the given XY
+   * - Deploy the probe, if not already deployed
+   * - Probe the bed, get the Z position
+   * - Depending on the 'stow' flag
+   *   - Stow the probe, or
+   *   - Raise to the BETWEEN height
+   * - Return the probed Z position
+   */
   float probe_pt(const float x, const float y, const bool stow/*=true*/, const int verbose_level/*=1*/) {
     #if ENABLED(DEBUG_LEVELING_FEATURE)
       if (DEBUGGING(LEVELING)) {
 
 #if ENABLED(AUTO_BED_LEVELING_BILINEAR) || ENABLED(MESH_BED_LEVELING)
 
-  //
-  // Enable if you prefer your output in JSON format
-  // suitable for SCAD or JavaScript mesh visualizers.
-  //
-  // Visualize meshes in OpenSCAD using the included script.
-  //
-  //   buildroot/shared/scripts/MarlinMesh.scad
-  //
+  /**
+   * Enable to produce output in JSON format suitable
+   * for SCAD or JavaScript mesh visualizers.
+   *
+   * Visualize meshes in OpenSCAD using the included script.
+   *
+   *   buildroot/shared/scripts/MarlinMesh.scad
+   */
   //#define SCAD_MESH_OUTPUT
 
   /**

Marlin/example_configurations/FolgerTech-i3-2020/Configuration.h

   #define K1 0.95 //smoothing factor within the PID
 
   // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it
-  
-    
+
   // FolgerTech i3-2020
   #define  DEFAULT_Kp 11.50
   #define  DEFAULT_Ki 0.50
     #define UBL_MESH_INSET 1         // Mesh inset margin on print area
     #define GRID_MAX_POINTS_X 10     // Don't use more than 15 points per axis, implementation limited.
     #define GRID_MAX_POINTS_Y 10
-    #define UBL_PROBE_PT_1_X 45    // These set the probe locations for when UBL does a 3-Point leveling	
+    #define UBL_PROBE_PT_1_X 45    // These set the probe locations for when UBL does a 3-Point leveling
     #define UBL_PROBE_PT_1_Y 170   // of the mesh.
     #define UBL_PROBE_PT_2_X 45
     #define UBL_PROBE_PT_2_Y 25

Marlin/example_configurations/gCreate_gMax1.5+/Configuration.h

 //#define MOTHERBOARD BOARD_RAMPS_14_EEF
   #define MOTHERBOARD BOARD_RAMPS_14_EFB       // gMax users please note:  This is a Roxy modification.   I print on glass and
                                                // I use Marlin to control the bed's temperature.  So, if you have a single nozzle
-                                               // machine, this will work fine for you.  You just set the 
-                                               // #define TEMP_SENSOR_BED 75 to 0 down below so Marlin doesn't mess with the bed 
+                                               // machine, this will work fine for you.  You just set the
+                                               // #define TEMP_SENSOR_BED 75 to 0 down below so Marlin doesn't mess with the bed
                                                // temp.
 #endif
 
 #define TEMP_SENSOR_3 0
 #define TEMP_SENSOR_4 0
 #define TEMP_SENSOR_BED 75   // gMax-1.5+ users please note:   This is a Roxy modification to the printer.   I want
-                             // to print on glass.   And I'm using a 400mm x 400mm silicon heat pad powered through 
-                             // a Fortek SSR to do it.   If you are using an unaltered gCreate machine, this needs 
+                             // to print on glass.   And I'm using a 400mm x 400mm silicon heat pad powered through
+                             // a Fortek SSR to do it.   If you are using an unaltered gCreate machine, this needs
                              // to be set to 0
 
 // Dummy thermistor constant temperature readings, for use with 998 and 999
   #define K1 0.95 //smoothing factor within the PID
 
   // If you are using a pre-configured hotend then you can use one of the value sets by uncommenting it
-  
+
   // gMax J-Head
     #define  DEFAULT_Kp 15.35
     #define  DEFAULT_Ki 0.85
     #define  DEFAULT_Kd 69.45
-    
+
   // Ultimaker
 //  #define  DEFAULT_Kp 22.2
 //  #define  DEFAULT_Ki 1.08
 #define Y_MIN_POS 0
 #define Z_MIN_POS 0
 #define X_MAX_POS 420		// These numbers are not accurate for an unaltered gMax 1.5+ printer.  My print bed
-#define Y_MAX_POS 420		// is inset a noticable amount from the edge of the bed.  Combined with the inset, 
+#define Y_MAX_POS 420		// is inset a noticable amount from the edge of the bed.  Combined with the inset,
                                 // the nozzle can reach all cordinates of the mesh.
 #define Z_MAX_POS 500
 

Marlin/language_tr.h

 #define MSG_FILAMENT_CHANGE_OPTION_EXTRUDE  _UxGT("Daha Akıt")                                          // Daha Akıt
 #define MSG_FILAMENT_CHANGE_OPTION_RESUME   _UxGT("Baskıyı sürdür")                                     // Baskıyı sürdür
 #define MSG_FILAMENT_CHANGE_MINTEMP         _UxGT("Min. Sıcaklık")                                      // Min. Sıcaklık:
-#define MSG_FILAMENT_CHANGE_NOZZLE          _UxGT("  Nozül: ")                                          //   Nozül: 
+#define MSG_FILAMENT_CHANGE_NOZZLE          _UxGT("  Nozül: ")                                          //   Nozül:
 
 #if LCD_HEIGHT >= 4
   // Up to 3 lines allowed

Marlin/softspi.h

  */
 static inline __attribute__((always_inline))
 void fastDigitalWrite(uint8_t pin, bool value) {
-	if (value) {
-		*portSetRegister(pin) = 1;
-	} else {
-		*portClearRegister(pin) = 1;
-	}
+  if (value) {
+    *portSetRegister(pin) = 1;
+  } else {
+    *portClearRegister(pin) = 1;
+  }
 }
 #else  // CORE_TEENSY
 //------------------------------------------------------------------------------
   /** Parenthesis operator
    * @return Pin's level
    */
-	inline operator bool () const __attribute__((always_inline)) {
+  inline operator bool () const __attribute__((always_inline)) {
     return read();
   }
   //----------------------------------------------------------------------------

Marlin/ubl_G29.cpp

   extern bool code_has_value();
   extern float probe_pt(float x, float y, bool, int);
   extern bool set_probe_deployed(bool);
-  void smart_fill_mesh();  
+  void smart_fill_mesh();
 
   bool ProbeStay = true;
 
-
   #define SIZE_OF_LITTLE_RAISE 0
   #define BIG_RAISE_NOT_NEEDED 0
   extern void lcd_quick_feedback();
    *   P3    Phase 3    Fill the unpopulated regions of the Mesh with a fixed value. There are two different paths the
    *                    user can go down.  If the user specifies the value using the C parameter, the closest invalid
    *                    mesh points to the nozzle will be filled.   The user can specify a repeat count using the R
-   *                    parameter with the C version of the command. 
+   *                    parameter with the C version of the command.
    *
-   *                    A second version of the fill command is available if no C constant is specified.  Not 
+   *                    A second version of the fill command is available if no C constant is specified.  Not
    *                    specifying a C constant will invoke the 'Smart Fill' algorithm.  The G29 P3 command will search
    *                    from the edges of the mesh inward looking for invalid mesh points.  It will look at the next
    *                    several mesh points to determine if the print bed is sloped up or down.  If the bed is sloped
-   *                    upward from the invalid mesh point, it will be replaced with the value of the nearest mesh point. 
+   *                    upward from the invalid mesh point, it will be replaced with the value of the nearest mesh point.
    *                    If the bed is sloped downward from the invalid mesh point, it will be replaced with a value that
    *                    puts all three points in a line.   The second version of the G29 P3 command is a quick, easy and
    *                    usually safe way to populate the unprobed regions of your mesh so you can continue to the G26
       repetition_cnt = code_has_value() ? code_value_int() : 1;
       while (repetition_cnt--) {
         if (cnt > 20) { cnt = 0; idle(); }
-        const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, x_pos, y_pos, USE_NOZZLE_AS_REFERENCE, NULL, false); 
+        const mesh_index_pair location = find_closest_mesh_point_of_type(REAL, x_pos, y_pos, USE_NOZZLE_AS_REFERENCE, NULL, false);
         if (location.x_index < 0) {
           SERIAL_PROTOCOLLNPGM("Entire Mesh invalidated.\n");
           break;            // No more invalid Mesh Points to populate
 
         case 3: {
           //
-          // Populate invalid Mesh areas.  Two choices are available to the user.  The user can 
+          // Populate invalid Mesh areas.  Two choices are available to the user.  The user can
           // specify the constant to be used with a C # paramter.   Or the user can allow the G29 P3 command to
           // apply a 'reasonable' constant to the invalid mesh point.  Some caution and scrutiny should be used
           // on either of these paths!
      * Z is negative, we need to invert the sign of all components of the vector
      */
     if ( normal.z < 0.0 ) {
-      normal.x = -normal.x; 
-      normal.y = -normal.y; 
-      normal.z = -normal.z; 
+      normal.x = -normal.x;
+      normal.y = -normal.y;
+      normal.z = -normal.z;
     }
 
     rotation = matrix_3x3::create_look_at( vector_3( normal.x,  normal.y, 1));
     for (i = 0; i < GRID_MAX_POINTS_X; i++) {
       for (j = 0; j < GRID_MAX_POINTS_Y; j++) {
         float x_tmp, y_tmp, z_tmp;
-          x_tmp = pgm_read_float(ubl.mesh_index_to_xpos[i]); 
+          x_tmp = pgm_read_float(ubl.mesh_index_to_xpos[i]);
           y_tmp = pgm_read_float(ubl.mesh_index_to_ypos[j]);
           z_tmp = ubl.z_values[i][j];
           #if ENABLED(DEBUG_LEVELING_FEATURE)
     float last_x = -9999.99, last_y = -9999.99;
     mesh_index_pair location;
     do {
-      location = find_closest_mesh_point_of_type(INVALID, lx, ly, USE_NOZZLE_AS_REFERENCE, NULL, false); 
+      location = find_closest_mesh_point_of_type(INVALID, lx, ly, USE_NOZZLE_AS_REFERENCE, NULL, false);
       // It doesn't matter if the probe can't reach the NAN location. This is a manual probe.
       if (location.x_index < 0 && location.y_index < 0) continue;
 
     do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE);
     do_blocking_move_to_xy(lx, ly);
     do {
-      location = find_closest_mesh_point_of_type(SET_IN_BITMAP, lx, ly, USE_NOZZLE_AS_REFERENCE, not_done, false); 
+      location = find_closest_mesh_point_of_type(SET_IN_BITMAP, lx, ly, USE_NOZZLE_AS_REFERENCE, not_done, false);
                                                                                               // It doesn't matter if the probe can not reach this
                                                                                               // location. This is a manual edit of the Mesh Point.
       if (location.x_index < 0 && location.y_index < 0) continue; // abort if we can't find any more points.
   }
 
   //
-  // The routine provides the 'Smart Fill' capability.  It scans from the 
+  // The routine provides the 'Smart Fill' capability.  It scans from the
   // outward edges of the mesh towards the center.  If it finds an invalid
   // location, it uses the next two points (assumming they are valid) to
   // calculate a 'reasonable' value for the unprobed mesh point.
     for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++) {             // Bottom of the mesh looking up
       for (uint8_t y = 0; y < GRID_MAX_POINTS_Y-2; y++) {
         if (isnan(ubl.z_values[x][y])) {
-          if (isnan(ubl.z_values[x][y+1]))                        // we only deal with the first NAN next to a block of 
+          if (isnan(ubl.z_values[x][y+1]))                        // we only deal with the first NAN next to a block of
             continue;                                             // good numbers.  we want 2 good numbers to extrapolate off of.
-          if (isnan(ubl.z_values[x][y+2]))  
-            continue;                      
+          if (isnan(ubl.z_values[x][y+2]))
+            continue;
           if (ubl.z_values[x][y+1] < ubl.z_values[x][y+2])        // The bed is angled down near this edge. So to be safe, we
             ubl.z_values[x][y] = ubl.z_values[x][y+1];            // use the closest value, which is probably a little too high
           else {
-            diff = ubl.z_values[x][y+1] - ubl.z_values[x][y+2];   // The bed is angled up near this edge. So we will use the closest 
+            diff = ubl.z_values[x][y+1] - ubl.z_values[x][y+2];   // The bed is angled up near this edge. So we will use the closest
             ubl.z_values[x][y] = ubl.z_values[x][y+1] + diff;     // height and add in the difference between that and the next point
           }
           break;
     for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++) {             // Top of the mesh looking down
       for (uint8_t y=GRID_MAX_POINTS_Y-1; y>=1; y--) {
         if (isnan(ubl.z_values[x][y])) {
-          if (isnan(ubl.z_values[x][y-1]))                        // we only deal with the first NAN next to a block of 
+          if (isnan(ubl.z_values[x][y-1]))                        // we only deal with the first NAN next to a block of
             continue;                                             // good numbers.  we want 2 good numbers to extrapolate off of.
-          if (isnan(ubl.z_values[x][y-2]))  
-            continue;                      
+          if (isnan(ubl.z_values[x][y-2]))
+            continue;
           if (ubl.z_values[x][y-1] < ubl.z_values[x][y-2])        // The bed is angled down near this edge. So to be safe, we
             ubl.z_values[x][y] = ubl.z_values[x][y-1];            // use the closest value, which is probably a little too high
           else {
-            diff = ubl.z_values[x][y-1] - ubl.z_values[x][y-2];   // The bed is angled up near this edge. So we will use the closest 
+            diff = ubl.z_values[x][y-1] - ubl.z_values[x][y-2];   // The bed is angled up near this edge. So we will use the closest
             ubl.z_values[x][y] = ubl.z_values[x][y-1] + diff;     // height and add in the difference between that and the next point
           }
           break;
     for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++) {
       for (uint8_t x = 0; x < GRID_MAX_POINTS_X-2; x++) {         // Left side of the mesh looking right
         if (isnan(ubl.z_values[x][y])) {
-          if (isnan(ubl.z_values[x+1][y]))                        // we only deal with the first NAN next to a block of 
+          if (isnan(ubl.z_values[x+1][y]))                        // we only deal with the first NAN next to a block of
             continue;                                             // good numbers.  we want 2 good numbers to extrapolate off of.
-          if (isnan(ubl.z_values[x+2][y]))  
-            continue;                      
+          if (isnan(ubl.z_values[x+2][y]))
+            continue;
           if (ubl.z_values[x+1][y] < ubl.z_values[x+2][y])        // The bed is angled down near this edge. So to be safe, we
             ubl.z_values[x][y] = ubl.z_values[x][y+1];            // use the closest value, which is probably a little too high
           else {
-            diff = ubl.z_values[x+1][y] - ubl.z_values[x+2][y];   // The bed is angled up near this edge. So we will use the closest 
+            diff = ubl.z_values[x+1][y] - ubl.z_values[x+2][y];   // The bed is angled up near this edge. So we will use the closest
             ubl.z_values[x][y] = ubl.z_values[x+1][y] + diff;     // height and add in the difference between that and the next point
           }
           break;
     for (uint8_t y=0; y < GRID_MAX_POINTS_Y; y++) {
       for (uint8_t x=GRID_MAX_POINTS_X-1; x>=1; x--) {            // Right side of the mesh looking left
         if (isnan(ubl.z_values[x][y])) {
-          if (isnan(ubl.z_values[x-1][y]))                        // we only deal with the first NAN next to a block of 
+          if (isnan(ubl.z_values[x-1][y]))                        // we only deal with the first NAN next to a block of
             continue;                                             // good numbers.  we want 2 good numbers to extrapolate off of.
-          if (isnan(ubl.z_values[x-2][y]))  
-            continue;                      
+          if (isnan(ubl.z_values[x-2][y]))
+            continue;
           if (ubl.z_values[x-1][y] < ubl.z_values[x-2][y])        // The bed is angled down near this edge. So to be safe, we
             ubl.z_values[x][y] = ubl.z_values[x-1][y];            // use the closest value, which is probably a little too high
           else {
-            diff = ubl.z_values[x-1][y] - ubl.z_values[x-2][y];   // The bed is angled up near this edge. So we will use the closest 
+            diff = ubl.z_values[x-1][y] - ubl.z_values[x-2][y];   // The bed is angled up near this edge. So we will use the closest
             ubl.z_values[x][y] = ubl.z_values[x-1][y] + diff;     // height and add in the difference between that and the next point
           }
           break;
-        } 
+        }
       }
     }
   }
     for(ix=0; ix<grid_size; ix++) {
       x = ((float)x_min) + ix*dx;
       for(iy=0; iy<grid_size; iy++) {
-        if (zig_zag) 
+        if (zig_zag)
           y = ((float)y_min) + (grid_size-iy-1)*dy;
         else
           y = ((float)y_min) + iy*dy;
     for (i = 0; i < GRID_MAX_POINTS_X; i++) {
       for (j = 0; j < GRID_MAX_POINTS_Y; j++) {
         float x_tmp, y_tmp, z_tmp;
-          x_tmp = pgm_read_float(&(ubl.mesh_index_to_xpos[i])); 
+          x_tmp = pgm_read_float(&(ubl.mesh_index_to_xpos[i]));
           y_tmp = pgm_read_float(&(ubl.mesh_index_to_ypos[j]));
           z_tmp = ubl.z_values[i][j];
           #if ENABLED(DEBUG_LEVELING_FEATURE)

Marlin/ultralcd_impl_HD44780.h

     lcd.clear();
 
     safe_delay(100);
-    
+
     lcd_set_custom_characters(
       #if ENABLED(LCD_PROGRESS_BAR)
         false

Marlin/utility.cpp

     thermalManager.manage_heater();
   }
   delay(ms);
-  thermalManager.manage_heater();	// This keeps us safe if too many small safe_delay() calls are made
+  thermalManager.manage_heater(); // This keeps us safe if too many small safe_delay() calls are made
 }
 
 #if ENABLED(ULTRA_LCD)