Formatting cleanup of quiet sources

Marlin/MarlinSerial.cpp

   ring_buffer rx_buffer  =  { { 0 }, 0, 0 };
 #endif
 
-FORCE_INLINE void store_char(unsigned char c)
-{
+FORCE_INLINE void store_char(unsigned char c) {
   int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE;
 
   // if we should be storing the received character into the location
 #if defined(M_USARTx_RX_vect)
   // fixed by Mark Sproul this is on the 644/644p
   //SIGNAL(SIG_USART_RECV)
-  SIGNAL(M_USARTx_RX_vect)
-  {
+  SIGNAL(M_USARTx_RX_vect) {
     unsigned char c  =  M_UDRx;
     store_char(c);
   }
 
 // Constructors ////////////////////////////////////////////////////////////////
 
-MarlinSerial::MarlinSerial()
-{
-
-}
+MarlinSerial::MarlinSerial() { }
 
 // Public Methods //////////////////////////////////////////////////////////////
 
-void MarlinSerial::begin(long baud)
-{
+void MarlinSerial::begin(long baud) {
   uint16_t baud_setting;
   bool useU2X = true;
 
-#if F_CPU == 16000000UL && SERIAL_PORT == 0
-  // hard-coded exception for compatibility with the bootloader shipped
-  // with the Duemilanove and previous boards and the firmware on the 8U2
-  // on the Uno and Mega 2560.
-  if (baud == 57600) {
-    useU2X = false;
-  }
-#endif
+  #if F_CPU == 16000000UL && SERIAL_PORT == 0
+    // hard-coded exception for compatibility with the bootloader shipped
+    // with the Duemilanove and previous boards and the firmware on the 8U2
+    // on the Uno and Mega 2560.
+    if (baud == 57600) {
+      useU2X = false;
+    }
+  #endif
   
   if (useU2X) {
     M_UCSRxA = 1 << M_U2Xx;
   sbi(M_UCSRxB, M_RXCIEx);
 }
 
-void MarlinSerial::end()
-{
+void MarlinSerial::end() {
   cbi(M_UCSRxB, M_RXENx);
   cbi(M_UCSRxB, M_TXENx);
   cbi(M_UCSRxB, M_RXCIEx);  
 }
 
 
-
-int MarlinSerial::peek(void)
-{
+int MarlinSerial::peek(void) {
   if (rx_buffer.head == rx_buffer.tail) {
     return -1;
   } else {
   }
 }
 
-int MarlinSerial::read(void)
-{
+int MarlinSerial::read(void) {
   // if the head isn't ahead of the tail, we don't have any characters
   if (rx_buffer.head == rx_buffer.tail) {
     return -1;
-  } else {
+  }
+  else {
     unsigned char c = rx_buffer.buffer[rx_buffer.tail];
     rx_buffer.tail = (unsigned int)(rx_buffer.tail + 1) % RX_BUFFER_SIZE;
     return c;
   }
 }
 
-void MarlinSerial::flush()
-{
+void MarlinSerial::flush() {
   // don't reverse this or there may be problems if the RX interrupt
   // occurs after reading the value of rx_buffer_head but before writing
   // the value to rx_buffer_tail; the previous value of rx_buffer_head
 }
 
 
-
-
 /// imports from print.h
 
 
-
-
-void MarlinSerial::print(char c, int base)
-{
+void MarlinSerial::print(char c, int base) {
   print((long) c, base);
 }
 
-void MarlinSerial::print(unsigned char b, int base)
-{
+void MarlinSerial::print(unsigned char b, int base) {
   print((unsigned long) b, base);
 }
 
-void MarlinSerial::print(int n, int base)
-{
+void MarlinSerial::print(int n, int base) {
   print((long) n, base);
 }
 
-void MarlinSerial::print(unsigned int n, int base)
-{
+void MarlinSerial::print(unsigned int n, int base) {
   print((unsigned long) n, base);
 }
 
-void MarlinSerial::print(long n, int base)
-{
+void MarlinSerial::print(long n, int base) {
   if (base == 0) {
     write(n);
-  } else if (base == 10) {
+  }
+  else if (base == 10) {
     if (n < 0) {
       print('-');
       n = -n;
   }
 }
 
-void MarlinSerial::print(unsigned long n, int base)
-{
+void MarlinSerial::print(unsigned long n, int base) {
   if (base == 0) write(n);
   else printNumber(n, base);
 }
 
-void MarlinSerial::print(double n, int digits)
-{
+void MarlinSerial::print(double n, int digits) {
   printFloat(n, digits);
 }
 
-void MarlinSerial::println(void)
-{
+void MarlinSerial::println(void) {
   print('\r');
   print('\n');  
 }
 
-void MarlinSerial::println(const String &s)
-{
+void MarlinSerial::println(const String &s) {
   print(s);
   println();
 }
 
-void MarlinSerial::println(const char c[])
-{
+void MarlinSerial::println(const char c[]) {
   print(c);
   println();
 }
 
-void MarlinSerial::println(char c, int base)
-{
+void MarlinSerial::println(char c, int base) {
   print(c, base);
   println();
 }
 
-void MarlinSerial::println(unsigned char b, int base)
-{
+void MarlinSerial::println(unsigned char b, int base) {
   print(b, base);
   println();
 }
 
-void MarlinSerial::println(int n, int base)
-{
+void MarlinSerial::println(int n, int base) {
   print(n, base);
   println();
 }
 
-void MarlinSerial::println(unsigned int n, int base)
-{
+void MarlinSerial::println(unsigned int n, int base) {
   print(n, base);
   println();
 }
 
-void MarlinSerial::println(long n, int base)
-{
+void MarlinSerial::println(long n, int base) {
   print(n, base);
   println();
 }
 
-void MarlinSerial::println(unsigned long n, int base)
-{
+void MarlinSerial::println(unsigned long n, int base) {
   print(n, base);
   println();
 }
 
-void MarlinSerial::println(double n, int digits)
-{
+void MarlinSerial::println(double n, int digits) {
   print(n, digits);
   println();
 }
 
 // Private Methods /////////////////////////////////////////////////////////////
 
-void MarlinSerial::printNumber(unsigned long n, uint8_t base)
-{
+void MarlinSerial::printNumber(unsigned long n, uint8_t base) {
   unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. 
   unsigned long i = 0;
 
       'A' + buf[i - 1] - 10));
 }
 
-void MarlinSerial::printFloat(double number, uint8_t digits) 
-{ 
+void MarlinSerial::printFloat(double number, uint8_t digits) {
   // Handle negative numbers
-  if (number < 0.0)
-  {
+  if (number < 0.0) {
      print('-');
      number = -number;
   }
 
   // Round correctly so that print(1.999, 2) prints as "2.00"
   double rounding = 0.5;
-  for (uint8_t i=0; i<digits; ++i)
+  for (uint8_t i = 0; i < digits; ++i)
     rounding /= 10.0;
   
   number += rounding;
     print("."); 
 
   // Extract digits from the remainder one at a time
-  while (digits-- > 0)
-  {
+  while (digits-- > 0) {
     remainder *= 10.0;
     int toPrint = int(remainder);
     print(toPrint);

Marlin/MarlinSerial.h

 #define MarlinSerial_h
 #include "Marlin.h"
 
-#if !defined(SERIAL_PORT) 
-#define SERIAL_PORT 0
+#ifndef SERIAL_PORT
+  #define SERIAL_PORT 0
 #endif
 
 // The presence of the UBRRH register is used to detect a UART.
 // requires two levels of indirection to expand macro values properly)
 #define SERIAL_REGNAME(registerbase,number,suffix) SERIAL_REGNAME_INTERNAL(registerbase,number,suffix)
 #if SERIAL_PORT == 0 && (!defined(UBRR0H) || !defined(UDR0)) // use un-numbered registers if necessary
-#define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
+  #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##suffix
 #else
-#define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
+  #define SERIAL_REGNAME_INTERNAL(registerbase,number,suffix) registerbase##number##suffix
 #endif
 
 // Registers used by MarlinSerial class (these are expanded 
 #define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,)
 
 
-
 #define DEC 10
 #define HEX 16
 #define OCT 8
 #define RX_BUFFER_SIZE 128
 
 
-struct ring_buffer
-{
+struct ring_buffer {
   unsigned char buffer[RX_BUFFER_SIZE];
   int head;
   int tail;
   extern ring_buffer rx_buffer;
 #endif
 
-class MarlinSerial //: public Stream
-{
+class MarlinSerial { //: public Stream
 
   public:
     MarlinSerial();
     int peek(void);
     int read(void);
     void flush(void);
-    
-    FORCE_INLINE int available(void)
-    {
+
+    FORCE_INLINE int available(void) {
       return (unsigned int)(RX_BUFFER_SIZE + rx_buffer.head - rx_buffer.tail) % RX_BUFFER_SIZE;
     }
-    
-    FORCE_INLINE void write(uint8_t c)
-    {
+
+    FORCE_INLINE void write(uint8_t c) {
       while (!((M_UCSRxA) & (1 << M_UDREx)))
         ;
 
       M_UDRx = c;
     }
-    
-    
-    FORCE_INLINE void checkRx(void)
-    {
-      if((M_UCSRxA & (1<<M_RXCx)) != 0) {
+
+    FORCE_INLINE void checkRx(void) {
+      if ((M_UCSRxA & (1<<M_RXCx)) != 0) {
         unsigned char c  =  M_UDRx;
         int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE;
 
         }
       }
     }
-    
-    
-    private:
+
+  private:
     void printNumber(unsigned long, uint8_t);
     void printFloat(double, uint8_t);
-    
-    
-  public:
-    
-    FORCE_INLINE void write(const char *str)
-    {
-      while (*str)
-        write(*str++);
-    }
 
+  public:
+    FORCE_INLINE void write(const char *str) { while (*str) write(*str++); }
+    FORCE_INLINE void write(const uint8_t *buffer, size_t size) { while (size--) write(*buffer++); }
+    FORCE_INLINE void print(const String &s) { for (int i = 0; i < (int)s.length(); i++) write(s[i]); }
+    FORCE_INLINE void print(const char *str) { write(str); }
 
-    FORCE_INLINE void write(const uint8_t *buffer, size_t size)
-    {
-      while (size--)
-        write(*buffer++);
-    }
-
-    FORCE_INLINE void print(const String &s)
-    {
-      for (int i = 0; i < (int)s.length(); i++) {
-        write(s[i]);
-      }
-    }
-    
-    FORCE_INLINE void print(const char *str)
-    {
-      write(str);
-    }
     void print(char, int = BYTE);
     void print(unsigned char, int = BYTE);
     void print(int, int = DEC);