use tabs instead of spaces for indentation

Author: lilian

.clang-format

@@ -233,8 +233,8 @@ StatementAttributeLikeMacros:
 StatementMacros:
   - Q_UNUSED
   - QT_REQUIRE_VERSION
-TabWidth:        8
-UseTab:          Never
+TabWidth:        4
+UseTab:        ForIndentation
 VerilogBreakBetweenInstancePorts: true
 WhitespaceSensitiveMacros:
   - BOOST_PP_STRINGIZE

.editorconfig

@@ -6,7 +6,7 @@ trim_trailing_whitespace = true
 insert_final_newline = true
 
 [*.{c,h,cpp,hpp}]
-indent_style = space
+indent_style = tab
 indent_size = 4
 
 [*.{go}]

src/SEGGER_RTT.c

@@ -302,25 +302,25 @@ Revision: $Rev: 24346 $
 // which is used as up-buffer (T->H)
 //
 typedef struct {
-    const char* sName;       // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
-    char* pBuffer;           // Pointer to start of buffer
-    unsigned SizeOfBuffer;   // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
-    unsigned WrOff;          // Position of next item to be written by either target.
-    volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host.
-    unsigned Flags;          // Contains configuration flags
+	const char* sName;       // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+	char* pBuffer;           // Pointer to start of buffer
+	unsigned SizeOfBuffer;   // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+	unsigned WrOff;          // Position of next item to be written by either target.
+	volatile unsigned RdOff; // Position of next item to be read by host. Must be volatile since it may be modified by host.
+	unsigned Flags;          // Contains configuration flags
 } SEGGER_RTT_BUFFER_UP;
 
 //
 // Description for a circular buffer (also called "ring buffer")
 // which is used as down-buffer (H->T)
 //
 typedef struct {
-    const char* sName;       // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
-    char* pBuffer;           // Pointer to start of buffer
-    unsigned SizeOfBuffer;   // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
-    volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host.
-    unsigned RdOff;          // Position of next item to be read by target (down-buffer).
-    unsigned Flags;          // Contains configuration flags
+	const char* sName;       // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+	char* pBuffer;           // Pointer to start of buffer
+	unsigned SizeOfBuffer;   // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+	volatile unsigned WrOff; // Position of next item to be written by host. Must be volatile since it may be modified by host.
+	unsigned RdOff;          // Position of next item to be read by target (down-buffer).
+	unsigned Flags;          // Contains configuration flags
 } SEGGER_RTT_BUFFER_DOWN;
 
 //
@@ -329,13 +329,13 @@ typedef struct {
 //
 //
 typedef struct {
-    char acID[16];                                                 // Initialized to "SEGGER RTT"
-    int MaxNumUpBuffers;                                           // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2)
-    int MaxNumDownBuffers;                                         // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2)
-    SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS];       // Up buffers, transferring information up from target via debug probe to host
-    SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target
+	char acID[16];                                                 // Initialized to "SEGGER RTT"
+	int MaxNumUpBuffers;                                           // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2)
+	int MaxNumDownBuffers;                                         // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2)
+	SEGGER_RTT_BUFFER_UP aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS];       // Up buffers, transferring information up from target via debug probe to host
+	SEGGER_RTT_BUFFER_DOWN aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS]; // Down buffers, transferring information down from host via debug probe to target
 #if SEGGER_RTT__CB_PADDING
-    unsigned char aDummy[SEGGER_RTT__CB_PADDING];
+	unsigned char aDummy[SEGGER_RTT__CB_PADDING];
 #endif
 } SEGGER_RTT_CB;
 

src/SEGGER_RTT.h

@@ -10,23 +10,23 @@
 //! @return Number of bytes successfully decoded.
 //! @note Stops decoding if delimiter byte is found. Code taken from Wikipedia and slightly modyfied.
 size_t COBSDecode(void* __restrict out, const void* __restrict in, size_t length) {
-    uint8_t* data = out;
-    const uint8_t* buffer = in;
-    const uint8_t* byte = buffer;     // Encoded input byte pointer
-    uint8_t* decode = (uint8_t*)data; // Decoded output byte pointer
+	uint8_t* data = out;
+	const uint8_t* buffer = in;
+	const uint8_t* byte = buffer;     // Encoded input byte pointer
+	uint8_t* decode = (uint8_t*)data; // Decoded output byte pointer
 
-    for (uint8_t code = 0xff, block = 0; byte < buffer + length; --block) {
-        if (block) { // Decode block byte
-            *decode++ = *byte++;
-        } else {
-            if (code != 0xff) { // Encoded zero, write it
-                *decode++ = 0;
-            }
-            block = code = *byte++; // Next block length
-            if (!code) {            // Delimiter code found
-                break;
-            }
-        }
-    }
-    return (size_t)(decode - data);
+	for (uint8_t code = 0xff, block = 0; byte < buffer + length; --block) {
+		if (block) { // Decode block byte
+			*decode++ = *byte++;
+		} else {
+			if (code != 0xff) { // Encoded zero, write it
+				*decode++ = 0;
+			}
+			block = code = *byte++; // Next block length
+			if (!code) {            // Delimiter code found
+				break;
+			}
+		}
+	}
+	return (size_t)(decode - data);
 }

src/cobsDecode.c

@@ -10,22 +10,22 @@
 //! @return Encoded buffer length in bytes.
 //! @note Does not output delimiter byte. Code taken from Wikipedia and slightly adapted.
 size_t COBSEncode(void* __restrict out, const void* __restrict in, size_t length) {
-    uint8_t* buffer = out;
-    uint8_t* encode = buffer;  // Encoded byte pointer
-    uint8_t* codep = encode++; // Output code pointer
-    uint8_t code = 1;          // Code value
+	uint8_t* buffer = out;
+	uint8_t* encode = buffer;  // Encoded byte pointer
+	uint8_t* codep = encode++; // Output code pointer
+	uint8_t code = 1;          // Code value
 
-    for (const uint8_t* byte = (const uint8_t*)in; length--; ++byte) {
-        if (*byte) { // Byte not zero, write it
-            *encode++ = *byte, ++code;
-        }
-        if (!*byte || code == 0xff) { // Input is zero or block completed, restart
-            *codep = code, code = 1, codep = encode;
-            if (!*byte || length) {
-                ++encode;
-            }
-        }
-    }
-    *codep = code; // Write final code value
-    return (size_t)(encode - buffer);
+	for (const uint8_t* byte = (const uint8_t*)in; length--; ++byte) {
+		if (*byte) { // Byte not zero, write it
+			*encode++ = *byte, ++code;
+		}
+		if (!*byte || code == 0xff) { // Input is zero or block completed, restart
+			*codep = code, code = 1, codep = encode;
+			if (!*byte || length) {
+				++encode;
+			}
+		}
+	}
+	*codep = code; // Write final code value
+	return (size_t)(encode - buffer);
 }

src/cobsEncode.c

@@ -14,105 +14,105 @@ static int sigilAndOffset(uint8_t* sigil, uint8_t b);
 static uint8_t repeatByte(int offset, uint8_t* in, int len);
 
 int TCOBSDecode(void* __restrict output, size_t max, const void* __restrict input, size_t length) {
-    uint8_t* in = (uint8_t*)input;
-    int ilen = (int)length; // remaining input length
-    uint8_t* out = (uint8_t*)output;
-    int olen = 0; // output length
-    while (ilen > 0) {
-        uint8_t next = in[ilen - 1]; // get next sigil byte (starting from the end)
-        uint8_t sigil;
-        uint8_t r;
-        int offset = sigilAndOffset(&sigil, next);
-        if (offset + 1 > ilen) {
-            return INPUT_DATA_CORRUPTED - __LINE__;
-        }
-        ilen -= 1; // remove sigil byte from buffer
-        switch (sigil) {
-        case N:
-            goto copyBytes;
+	uint8_t* in = (uint8_t*)input;
+	int ilen = (int)length; // remaining input length
+	uint8_t* out = (uint8_t*)output;
+	int olen = 0; // output length
+	while (ilen > 0) {
+		uint8_t next = in[ilen - 1]; // get next sigil byte (starting from the end)
+		uint8_t sigil;
+		uint8_t r;
+		int offset = sigilAndOffset(&sigil, next);
+		if (offset + 1 > ilen) {
+			return INPUT_DATA_CORRUPTED - __LINE__;
+		}
+		ilen -= 1; // remove sigil byte from buffer
+		switch (sigil) {
+		case N:
+			goto copyBytes;
 
-        case Z3:
-            olen += 1;
-            out[max - olen] = 0;
-            // fallthrough
-        case Z2:
-            olen += 1;
-            out[max - olen] = 0;
-            // fallthrough
-        case Z1:
-            olen += 1;
-            out[max - olen] = 0;
-            goto copyBytes;
+		case Z3:
+			olen += 1;
+			out[max - olen] = 0;
+			// fallthrough
+		case Z2:
+			olen += 1;
+			out[max - olen] = 0;
+			// fallthrough
+		case Z1:
+			olen += 1;
+			out[max - olen] = 0;
+			goto copyBytes;
 
-        case F4:
-            olen += 1;
-            out[max - olen] = 0xFF;
-            // fallthrough
-        case F3:
-            olen += 1;
-            out[max - olen] = 0xFF;
-            // fallthrough
-        case F2:
-            olen += 1;
-            out[max - olen] = 0xFF;
-            olen += 1;
-            out[max - olen] = 0xFF;
-            goto copyBytes;
+		case F4:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			// fallthrough
+		case F3:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			// fallthrough
+		case F2:
+			olen += 1;
+			out[max - olen] = 0xFF;
+			olen += 1;
+			out[max - olen] = 0xFF;
+			goto copyBytes;
 
-        case R4:
-            olen += 1;
-            out[max - olen] = repeatByte(offset, in, ilen);
-            // fallthrough
-        case R3:
-            olen += 1;
-            out[max - olen] = repeatByte(offset, in, ilen);
-            // fallthrough
-        case R2:
-            r = repeatByte(offset, in, ilen);
-            olen += 1;
-            out[max - olen] = r;
-            olen += 1;
-            out[max - olen] = r;
-            goto copyBytes;
+		case R4:
+			olen += 1;
+			out[max - olen] = repeatByte(offset, in, ilen);
+			// fallthrough
+		case R3:
+			olen += 1;
+			out[max - olen] = repeatByte(offset, in, ilen);
+			// fallthrough
+		case R2:
+			r = repeatByte(offset, in, ilen);
+			olen += 1;
+			out[max - olen] = r;
+			olen += 1;
+			out[max - olen] = r;
+			goto copyBytes;
 
-        default:
-            return INPUT_DATA_CORRUPTED - __LINE__;
-        }
+		default:
+			return INPUT_DATA_CORRUPTED - __LINE__;
+		}
 
-    copyBytes: {
-        uint8_t* to = out + max - olen - offset; // to := len(d) - n - offset
-        uint8_t* from = in + ilen - offset;      // from := len(in) - offset // sigil byte is already removed
-        if (to < out) {
-            return OUT_BUFFER_TOO_SMALL - __LINE__;
-        }
-        memcpy(to, from, offset); // n += copy(d[to:], in[from:])
-        olen += offset;
-        ilen -= offset; // in = in[:len(in)-offset] // remove copied bytes
-        continue;
-    }
-    }
-    return olen;
+	copyBytes: {
+		uint8_t* to = out + max - olen - offset; // to := len(d) - n - offset
+		uint8_t* from = in + ilen - offset;      // from := len(in) - offset // sigil byte is already removed
+		if (to < out) {
+			return OUT_BUFFER_TOO_SMALL - __LINE__;
+		}
+		memcpy(to, from, offset); // n += copy(d[to:], in[from:])
+		olen += offset;
+		ilen -= offset; // in = in[:len(in)-offset] // remove copied bytes
+		continue;
+	}
+	}
+	return olen;
 }
 
 // sigilAndOffset interprets b as sigil byte with offset, fills sigil and returns offset.
 // For details see TCOBSv1Specification.md.
 static int sigilAndOffset(uint8_t* sigil, uint8_t b) {
-    int offset;
-    *sigil = b & 0xE0; // 0x11100000
-    if (*sigil == 0) {
-        *sigil = b & 0xF8; // 0x11111000
-        offset = 7 & b;    // 0x00000111
-    } else {
-        offset = 0x1F & b; // 0x00011111
-    }
-    return offset;
+	int offset;
+	*sigil = b & 0xE0; // 0x11100000
+	if (*sigil == 0) {
+		*sigil = b & 0xF8; // 0x11111000
+		offset = 7 & b;    // 0x00000111
+	} else {
+		offset = 0x1F & b; // 0x00011111
+	}
+	return offset;
 }
 
 // repeatByte returns the value to repeat
 static uint8_t repeatByte(int offset, uint8_t* in, int len) {
-    if (offset == 0) {      // left byte of Ri is a sigil byte (probably N)
-        return in[len - 2]; // a buffer cannot start with Ri
-    } else {
-        return in[len - 1];
-    }
+	if (offset == 0) {      // left byte of Ri is a sigil byte (probably N)
+		return in[len - 2]; // a buffer cannot start with Ri
+	} else {
+		return in[len - 1];
+	}
 }