Merge pull request #1407 from thinkyhead/cleanup_marlinserial

Formatting cleanup of quiet sources

Marlin/MarlinSerial.cpp

@@ -32,8 +32,7 @@
   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
@@ -51,8 +50,7 @@ FORCE_INLINE void store_char(unsigned char c)
 #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);
   }
@@ -60,26 +58,22 @@ FORCE_INLINE void store_char(unsigned 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
+  #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
+  #endif
   
   if (useU2X) {
     M_UCSRxA = 1 << M_U2Xx;
@@ -98,17 +92,14 @@ void MarlinSerial::begin(long baud)
   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 {
@@ -116,20 +107,19 @@ int MarlinSerial::peek(void)
   }
 }
 
-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
@@ -143,38 +133,30 @@ void MarlinSerial::flush()
 }
 
 
-
-
 /// 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;
@@ -185,81 +167,68 @@ void MarlinSerial::print(long n, int base)
   }
 }
 
-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;
 
@@ -279,18 +248,16 @@ void MarlinSerial::printNumber(unsigned long n, uint8_t base)
       '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;
@@ -305,8 +272,7 @@ void MarlinSerial::printFloat(double number, uint8_t digits)
     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

@@ -23,8 +23,8 @@
 #define MarlinSerial_h
 #include "Marlin.h"
 
-#if !defined(SERIAL_PORT) 
+#ifndef SERIAL_PORT
-#define SERIAL_PORT 0
+  #define SERIAL_PORT 0
 #endif
 
 // The presence of the UBRRH register is used to detect a UART.
@@ -36,9 +36,9 @@
 // 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 
@@ -57,7 +57,6 @@
 #define M_U2Xx SERIAL_REGNAME(U2X,SERIAL_PORT,)
 
 
-
 #define DEC 10
 #define HEX 16
 #define OCT 8
@@ -73,8 +72,7 @@
 #define RX_BUFFER_SIZE 128
 
 
-struct ring_buffer
+struct ring_buffer {
-{
   unsigned char buffer[RX_BUFFER_SIZE];
   int head;
   int tail;
@@ -84,8 +82,7 @@ struct ring_buffer
   extern ring_buffer rx_buffer;
 #endif
 
-class MarlinSerial //: public Stream
+class MarlinSerial { //: public Stream
-{
 
   public:
     MarlinSerial();
@@ -95,23 +92,19 @@ class MarlinSerial //: public Stream
     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) {
-    FORCE_INLINE void checkRx(void)
+      if ((M_UCSRxA & (1<<M_RXCx)) != 0) {
-    {
-      if((M_UCSRxA & (1<<M_RXCx)) != 0) {
         unsigned char c  =  M_UDRx;
         int i = (unsigned int)(rx_buffer.head + 1) % RX_BUFFER_SIZE;
 
@@ -126,38 +119,16 @@ class MarlinSerial //: public Stream
       }
     }
 
-    
   private:
     void printNumber(unsigned long, uint8_t);
     void printFloat(double, uint8_t);
 
-    
   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 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);
-    }
     void print(char, int = BYTE);
     void print(unsigned char, int = BYTE);
     void print(int, int = DEC);