diff --git a/src/UsefulBuf.c b/src/UsefulBuf.c
index 0c336b8..1d13f10 100644
--- a/src/UsefulBuf.c
+++ b/src/UsefulBuf.c
@@ -1,6 +1,6 @@
 /*==============================================================================
  Copyright (c) 2016-2018, The Linux Foundation.
- Copyright (c) 2018-2019, Laurence Lundblade.
+ Copyright (c) 2018-2020, Laurence Lundblade.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -27,9 +27,9 @@
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- ==============================================================================*/
+ =============================================================================*/
 
-/*===================================================================================
+/*=============================================================================
  FILE:  UsefulBuf.c
 
  DESCRIPTION:  General purpose input and output buffers
@@ -39,24 +39,26 @@
  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.
 
- when               who             what, where, why
- --------           ----            ---------------------------------------------------
- 11/08/2019         llundblade      Re check pointer math and update comments
- 3/6/2019           llundblade      Add UsefulBuf_IsValue()
- 09/07/17           llundbla        Fix critical bug in UsefulBuf_Find() -- a read off
-                                    the end of memory when the bytes to find is longer
-                                    than the bytes to search.
- 06/27/17           llundbla        Fix UsefulBuf_Compare() bug. Only affected comparison
-                                    for < or > for unequal length buffers.  Added
-                                    UsefulBuf_Set() function.
- 05/30/17           llundbla        Functions for NULL UsefulBufs and const / unconst
- 11/13/16           llundbla        Initial Version.
+ when        who          what, where, why
+ --------    ----         ---------------------------------------------------
+ 01/08/2020 llundblade    Documentation corrections & improved code formatting.
+ 11/08/2019  llundblade   Re check pointer math and update comments
+ 3/6/2019    llundblade   Add UsefulBuf_IsValue()
+ 09/07/17    llundbla     Fix critical bug in UsefulBuf_Find() -- a read off
+                          the end of memory when the bytes to find is longer
+                          than the bytes to search.
+ 06/27/17    llundbla     Fix UsefulBuf_Compare() bug. Only affected comparison
+                          for < or > for unequal length buffers.  Added
+                          UsefulBuf_Set() function.
+ 05/30/17    llundbla     Functions for NULL UsefulBufs and const / unconst
+ 11/13/16    llundbla     Initial Version.
 
- =====================================================================================*/
+ ============================================================================*/
 
 #include "UsefulBuf.h"
 
-#define USEFUL_OUT_BUF_MAGIC  (0x0B0F) // used to catch use of uninitialized or corrupted UOBs
+// used to catch use of uninitialized or corrupted UsefulOutBuf
+#define USEFUL_OUT_BUF_MAGIC  (0x0B0F)
 
 
 /*
@@ -64,7 +66,8 @@
  */
 UsefulBufC UsefulBuf_CopyOffset(UsefulBuf Dest, size_t uOffset, const UsefulBufC Src)
 {
-   // Do this with subtraction so it doesn't give erroneous result if uOffset + Src.len overflows
+   // Do this with subtraction so it doesn't give erroneous
+   // result if uOffset + Src.len overflows
    if(uOffset > Dest.len || Src.len > Dest.len - uOffset) { // uOffset + Src.len > Dest.len
       return NULLUsefulBufC;
    }
@@ -166,11 +169,13 @@
 /*
  Public function -- see UsefulBuf.h
 
- The core of UsefulOutBuf -- put some bytes in the buffer without writing off the end of it.
+ The core of UsefulOutBuf -- put some bytes in the buffer without writing off
+                             the end of it.
 
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
 
- This function inserts the source buffer, NewData, into the destination buffer, me->UB.ptr.
+ This function inserts the source buffer, NewData, into the destination
+ buffer, me->UB.ptr.
 
  Destination is represented as:
    me->UB.ptr -- start of the buffer
@@ -192,7 +197,8 @@
 
  2. Is insertion position in the range of valid data?
 
- 3. If insertion point is not at the end, slide data to the right of the insertion point to the right
+ 3. If insertion point is not at the end, slide data to the right of the
+    insertion point to the right
 
  4. Put the new data in at the insertion position.
 
@@ -219,7 +225,9 @@
    // be sure there is no pointer arithmatic under/overflow.
    if(pMe->data_len > pMe->UB.len) {  // Check #1
       pMe->err = 1;
-      return; // Offset of valid data is off the end of the UsefulOutBuf due to uninitialization or corruption
+      // Offset of valid data is off the end of the UsefulOutBuf due to
+      // uninitialization or corruption
+      return;
    }
 
    /* 1. Will it fit? */
@@ -330,7 +338,7 @@
 /*
  Public function -- see UsefulBuf.h
 
- The core of UsefulInputBuf -- consume some bytes without going off the end of the buffer.
+ The core of UsefulInputBuf -- consume bytes without going off end of buffer.
 
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
  */
@@ -342,14 +350,15 @@
    }
 
    if(!UsefulInputBuf_BytesAvailable(pMe, uAmount)) {
-      // The number of bytes asked for at current position are more than available
+      // Number of bytes asked for at current position are more than available
       pMe->err = 1;
       return NULL;
    }
 
    // This is going to succeed
    const void * const result = ((uint8_t *)pMe->UB.ptr) + pMe->cursor;
-   pMe->cursor += uAmount; // this will not overflow because of check using UsefulInputBuf_BytesAvailable()
+   // Will not overflow because of check using UsefulInputBuf_BytesAvailable()
+   pMe->cursor += uAmount;
    return result;
 }
 
diff --git a/src/ieee754.c b/src/ieee754.c
index 6fdfda8..ea44e1d 100644
--- a/src/ieee754.c
+++ b/src/ieee754.c
@@ -1,35 +1,42 @@
 /*==============================================================================
- ieee754.c -- floating point conversion between half, double and single precision
+ ieee754.c -- floating-point conversion between half, double & single-precision
 
- Copyright (c) 2018-2019, Laurence Lundblade. All rights reserved.
+ Copyright (c) 2018-2020, Laurence Lundblade. All rights reserved.
 
  SPDX-License-Identifier: BSD-3-Clause
 
  See BSD-3-Clause license in README.md
 
  Created on 7/23/18
- ==============================================================================*/
+ =============================================================================*/
 
 #include "ieee754.h"
 #include <string.h> // For memcpy()
 
 
 /*
- This code is written for clarity and verifiability, not for size, on the assumption
- that the optimizer will do a good job. The LLVM optimizer, -Os, does seem to do the
- job and the resulting object code is smaller from combining code for the many different
- cases (normal, subnormal, infinity, zero...) for the conversions.
+ This code is written for clarity and verifiability, not for size, on
+ the assumption that the optimizer will do a good job. The LLVM
+ optimizer, -Os, does seem to do the job and the resulting object code
+ is smaller from combining code for the many different cases (normal,
+ subnormal, infinity, zero...) for the conversions.
 
- Dead stripping is also really helpful to get code size down when floating point
- encoding is not needed.
+ This code has really long lines and is much easier to read because of
+ them. Some coding guidelines prefer 80 column lines (can they not afford
+ big displays?). It would make this code much worse even to wrap at 120
+ columns.
 
- This code works solely using shifts and masks and thus has no dependency on
- any math libraries. It can even work if the CPU doesn't have any floating
- point support, though that isn't the most useful thing to do.
+ Dead stripping is also really helpful to get code size down when
+ floating-point encoding is not needed.
 
- The memcpy() dependency is only for CopyFloatToUint32() and friends which only
- is needed to avoid type punning when converting the actual float bits to
- an unsigned value so the bit shifts and masks can work.
+ This code works solely using shifts and masks and thus has no
+ dependency on any math libraries. It can even work if the CPU doesn't
+ have any floating-point support, though that isn't the most useful
+ thing to do.
+
+ The memcpy() dependency is only for CopyFloatToUint32() and friends
+ which only is needed to avoid type punning when converting the actual
+ float bits to an unsigned value so the bit shifts and masks can work.
  */
 
 /*
@@ -69,7 +76,7 @@
 #define HALF_EXPONENT_INF_OR_NAN  (HALF_EXPONENT_BIAS+1)  //  16 Unbiased
 
 
-// ------ Single Precision --------
+// ------ Single-Precision --------
 #define SINGLE_NUM_SIGNIFICAND_BITS (23)
 #define SINGLE_NUM_EXPONENT_BITS    (8)
 #define SINGLE_NUM_SIGN_BITS        (1)
@@ -96,7 +103,7 @@
 #define SINGLE_EXPONENT_INF_OR_NAN  (SINGLE_EXPONENT_BIAS+1)  // 128  unbiased
 
 
-// --------- Double Precision ----------
+// --------- Double-Precision ----------
 #define DOUBLE_NUM_SIGNIFICAND_BITS (52)
 #define DOUBLE_NUM_EXPONENT_BITS    (11)
 #define DOUBLE_NUM_SIGN_BITS        (1)
@@ -349,7 +356,7 @@
     uSingleSign = uHalfSign;
 
 
-    // Shift the three parts of the single precision into place
+    // Shift the three parts of the single-precision into place
     const uint32_t uSinglePrecision = uSingleSignificand |
                                      (uSingleBiasedExponent << SINGLE_EXPONENT_SHIFT) |
                                      (uSingleSign << SINGLE_SIGN_SHIFT);
diff --git a/src/ieee754.h b/src/ieee754.h
index 2530f98..d2c1224 100644
--- a/src/ieee754.h
+++ b/src/ieee754.h
@@ -1,14 +1,14 @@
 /*==============================================================================
- ieee754.c -- floating point conversion between half, double and single precision
+ ieee754.c -- floating-point conversion between half, double & single-precision
 
- Copyright (c) 2018-2019, Laurence Lundblade. All rights reserved.
+ Copyright (c) 2018-2020, Laurence Lundblade. All rights reserved.
 
  SPDX-License-Identifier: BSD-3-Clause
 
  See BSD-3-Clause license in README.md
 
  Created on 7/23/18
- ==============================================================================*/
+ =============================================================================*/
 
 #ifndef ieee754_h
 #define ieee754_h
@@ -20,94 +20,77 @@
 /*
  General comments
 
- This is a complete in that it handles all conversion cases
- including +/- infinity, +/- zero, subnormal numbers, qNaN, sNaN
- and NaN payloads.
+ This is a complete in that it handles all conversion cases including
+ +/- infinity, +/- zero, subnormal numbers, qNaN, sNaN and NaN
+ payloads.
 
- This confirms to IEEE 754-2008, but note that this doesn't
- specify conversions, just the encodings.
+ This confirms to IEEE 754-2008, but note that this doesn't specify
+ conversions, just the encodings.
 
- NaN payloads are preserved with alignment on the LSB. The
- qNaN bit is handled differently and explicity copied. It
- is always the MSB of the significand. The NaN payload MSBs
- (except the qNaN bit) are truncated when going from
- double or single to half.
+ NaN payloads are preserved with alignment on the LSB. The qNaN bit is
+ handled differently and explicity copied. It is always the MSB of the
+ significand. The NaN payload MSBs (except the qNaN bit) are truncated
+ when going from double or single to half.
 
  TODO: what does the C cast do with NaN payloads from
- double to single?
-
-
+ double to single? It probably depends entirely on the
+ CPU.
 
  */
 
 /*
- Most simply just explicilty encode the type you want, single or double.
- This works easily everywhere since standard C supports both
- these types and so does qcbor.  This encoder also supports
- half precision and there's a few ways to use it to encode
- floating point numbers in less space.
+ Most simply just explicilty encode the type you want, single or
+ double.  This works easily everywhere since standard C supports both
+ these types and so does qcbor.  This encoder also supports half
+ precision and there's a few ways to use it to encode floating-point
+ numbers in less space.
 
- Without losing precision, you can encode a single or double
- such that the special values of 0, NaN and Infinity encode
- as half-precision.  This CBOR decodoer and most others
- should handle this properly.
+ Without losing precision, you can encode a single or double such that
+ the special values of 0, NaN and Infinity encode as half-precision.
+ This CBOR decodoer and most others should handle this properly.
 
  If you don't mind losing precision, then you can use half-precision.
  One way to do this is to set up your environment to use
  ___fp_16. Some compilers and CPUs support it even though it is not
- standard C. What is nice about this is that your program
- will use less memory and floating point operations like
- multiplying, adding and such will be faster.
+ standard C. What is nice about this is that your program will use
+ less memory and floating-point operations like multiplying, adding
+ and such will be faster.
 
- Another way to make use of half-precision is to represent
- the values in your program as single or double, but encode
- them in CBOR as half-precision. This cuts the size
- of the encoded messages by 2 or 4, but doesn't reduce
- memory needs or speed because you are still using
+ Another way to make use of half-precision is to represent the values
+ in your program as single or double, but encode them in CBOR as
+ half-precision. This cuts the size of the encoded messages by 2 or 4,
+ but doesn't reduce memory needs or speed because you are still using
  single or double in your code.
 
-
- encode:
-    - float as float
-    - double as double
-    - half as half
- - float as half_precision, for environments that don't support a half-precision type
- - double as half_precision, for environments that don't support a half-precision type
- - float with NaN, Infinity and 0 as half
- - double with NaN, Infinity and 0 as half
-
-
-
-
  */
 
 
 
 /*
- Convert single precision float to half-precision float.
- Precision and NaN payload bits will be lost. Too large
- values will round up to infinity and too small to zero.
+ Convert single-precision float to half-precision float.  Precision
+ and NaN payload bits will be lost. Too-large values will round up to
+ infinity and too small to zero.
  */
 uint16_t IEEE754_FloatToHalf(float f);
 
 
 /*
- Convert half precision float to single precision float.
- This is a loss-less conversion.
+ Convert half-precision float to single-precision float.  This is a
+ loss-less conversion.
  */
 float IEEE754_HalfToFloat(uint16_t uHalfPrecision);
 
 
 /*
- Convert double precision float to half-precision float.
- Precision and NaN payload bits will be lost. Too large
- values will round up to infinity and too small to zero.
+ Convert double-precision float to half-precision float.  Precision
+ and NaN payload bits will be lost. Too-large values will round up to
+ infinity and too small to zero.
  */
 uint16_t IEEE754_DoubleToHalf(double d);
 
 
 /*
- Convert half precision float to double precision float.
+ Convert half-precision float to double-precision float.
  This is a loss-less conversion.
  */
 double IEEE754_HalfToDouble(uint16_t uHalfPrecision);
@@ -126,9 +109,10 @@
 
 
 /*
- Converts double-precision to single-precision or half-precision if possible without
- loss of precisions. If not, leaves it as a double. Only converts to single-precision
- unless bAllowHalfPrecision is set.
+ Converts double-precision to single-precision or half-precision if
+ possible without loss of precisions. If not, leaves it as a
+ double. Only converts to single-precision unless bAllowHalfPrecision
+ is set.
  */
 IEEE754_union IEEE754_DoubleToSmallestInternal(double d, int bAllowHalfPrecision);
 
@@ -143,17 +127,18 @@
 
 
 /*
- Converts double-precision to single-precision or half-precision if possible without
- loss of precisions. If not, leaves it as a double.
+ Converts double-precision to single-precision or half-precision if
+ possible without loss of precisions. If not, leaves it as a double.
  */
 static inline IEEE754_union IEEE754_DoubleToSmallest(double d)
 {
     return IEEE754_DoubleToSmallestInternal(d, 1);
 }
 
+
 /*
- Converts single-precision to half-precision if possible without
- loss of precision. If not leaves as single-precision.
+ Converts single-precision to half-precision if possible without loss
+ of precision. If not leaves as single-precision.
  */
 IEEE754_union IEEE754_FloatToSmallest(float f);
 
diff --git a/src/qcbor_decode.c b/src/qcbor_decode.c
index a51c597..26bc3f6 100644
--- a/src/qcbor_decode.c
+++ b/src/qcbor_decode.c
@@ -1,6 +1,6 @@
 /*==============================================================================
  Copyright (c) 2016-2018, The Linux Foundation.
- Copyright (c) 2018-2019, Laurence Lundblade.
+ Copyright (c) 2018-2020, Laurence Lundblade.
  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -28,9 +28,9 @@
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- ==============================================================================*/
+ =============================================================================*/
 
-/*===================================================================================
+/*==============================================================================
  FILE:  qcbor_decode.c
 
  DESCRIPTION:  This file contains the implementation of QCBOR.
@@ -40,31 +40,33 @@
  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.
 
- when               who             what, where, why
- --------           ----            ---------------------------------------------------
- 12/30/19           llundblade      Add support for decimal fractions and bigfloats.
- 11/07/19           llundblade      Fix long long conversion to double compiler warning
- 09/07/19           llundblade      Fix bug decoding empty arrays and maps
- 07/31/19           llundblade      Decode error fixes for some not-well-formed CBOR
- 07/31/19           llundblade      New error code for better end of data handling
- 02/17/19           llundblade      Fixed: QCBORItem.u{Data|Label}Alloc when bAllStrings set
- 02/16/19           llundblade      Redesign MemPool to fix memory access alignment bug
- 01/10/19           llundblade      Clever type and argument decoder is 250 bytes smaller
- 11/9/18            llundblade      Error codes are now enums.
- 11/2/18            llundblade      Simplify float decoding and align with preferred
-                                    float encoding
- 10/31/18           llundblade      Switch to one license that is almost BSD-3.
- 10/28/18           llundblade      Reworked tag decoding
- 10/15/18           llundblade      Indefinite length maps and arrays supported
- 10/8/18            llundblade      Indefinite length strings supported
- 02/04/17           llundbla        Work on CPUs that don's require pointer alignment
-                                    by making use of changes in UsefulBuf
- 03/01/17           llundbla        More data types; decoding improvements and fixes
- 11/13/16           llundbla        Integrate most TZ changes back into github version.
- 09/30/16           gkanike         Porting to TZ.
- 03/15/16           llundbla        Initial Version.
+ when       who             what, where, why
+ --------   ----            ---------------------------------------------------
+ 01/08/2020 llundblade      Documentation corrections & improved code formatting.
+ 12/30/19   llundblade      Add support for decimal fractions and bigfloats.
+ 11/07/19   llundblade      Fix long long conversion to double compiler warning
+ 09/07/19   llundblade      Fix bug decoding empty arrays and maps
+ 07/31/19   llundblade      Decode error fixes for some not-well-formed CBOR
+ 07/31/19   llundblade      New error code for better end of data handling
+ 02/17/19   llundblade      Fixed: QCBORItem.u{Data|Label}Alloc when
+                            bAllStrings set
+ 02/16/19   llundblade      Redesign MemPool to fix memory access alignment bug
+ 01/10/19   llundblade      Clever type and argument decoder; 250 bytes smaller
+ 11/9/18    llundblade      Error codes are now enums.
+ 11/2/18    llundblade      Simplify float decoding and align with preferred
+                            float encoding
+ 10/31/18   llundblade      Switch to one license that is almost BSD-3.
+ 10/28/18   llundblade      Reworked tag decoding
+ 10/15/18   llundblade      Indefinite length maps and arrays supported
+ 10/8/18    llundblade      Indefinite length strings supported
+ 02/04/17   llundbla        Work on CPUs that don's require pointer alignment
+                            by making use of changes in UsefulBuf
+ 03/01/17   llundbla        More data types; decoding improvements and fixes
+ 11/13/16   llundbla        Integrate most TZ changes back into github version.
+ 09/30/16   gkanike         Porting to TZ.
+ 03/15/16   llundbla        Initial Version.
 
- =====================================================================================*/
+ =============================================================================*/
 
 #include "qcbor.h"
 #include "ieee754.h"
@@ -77,31 +79,39 @@
 #define UNCONST_POINTER(ptr)    ((void *)(ptr))
 
 
-/*
- Collection of functions to track the map/array nesting for decoding
- */
 
-inline static int IsMapOrArray(uint8_t uDataType)
+/*===========================================================================
+ DecodeNesting -- Functions for tracking array/map nesting when decoding
+
+ See qcbor.h for definition of the object used here: QCBORDecodeNesting
+  ===========================================================================*/
+
+inline static int
+IsMapOrArray(uint8_t uDataType)
 {
    return uDataType == QCBOR_TYPE_MAP || uDataType == QCBOR_TYPE_ARRAY;
 }
 
-inline static int DecodeNesting_IsNested(const QCBORDecodeNesting *pNesting)
+inline static int
+DecodeNesting_IsNested(const QCBORDecodeNesting *pNesting)
 {
    return pNesting->pCurrent != &(pNesting->pMapsAndArrays[0]);
 }
 
-inline static int DecodeNesting_IsIndefiniteLength(const QCBORDecodeNesting *pNesting)
+inline static int
+DecodeNesting_IsIndefiniteLength(const QCBORDecodeNesting *pNesting)
 {
    return pNesting->pCurrent->uCount == UINT16_MAX;
 }
 
-inline static uint8_t DecodeNesting_GetLevel(QCBORDecodeNesting *pNesting)
+inline static uint8_t
+DecodeNesting_GetLevel(QCBORDecodeNesting *pNesting)
 {
    return pNesting->pCurrent - &(pNesting->pMapsAndArrays[0]);
 }
 
-inline static int DecodeNesting_TypeIsMap(const QCBORDecodeNesting *pNesting)
+inline static int
+DecodeNesting_TypeIsMap(const QCBORDecodeNesting *pNesting)
 {
    if(!DecodeNesting_IsNested(pNesting)) {
       return 0;
@@ -111,7 +121,8 @@
 }
 
 // Process a break. This will either ascend the nesting or error out
-inline static QCBORError DecodeNesting_BreakAscend(QCBORDecodeNesting *pNesting)
+inline static QCBORError
+DecodeNesting_BreakAscend(QCBORDecodeNesting *pNesting)
 {
    // breaks must always occur when there is nesting
    if(!DecodeNesting_IsNested(pNesting)) {
@@ -129,8 +140,9 @@
    return QCBOR_SUCCESS;
 }
 
-// Called on every single item except breaks including the opening of a map/array
-inline static void DecodeNesting_DecrementCount(QCBORDecodeNesting *pNesting)
+// Called on every single item except breaks including open of a map/array
+inline static void
+DecodeNesting_DecrementCount(QCBORDecodeNesting *pNesting)
 {
    while(DecodeNesting_IsNested(pNesting)) {
       // Not at the top level, so there is decrementing to be done.
@@ -152,9 +164,9 @@
    }
 }
 
-
 // Called on every map/array
-inline static QCBORError DecodeNesting_Descend(QCBORDecodeNesting *pNesting, QCBORItem *pItem)
+inline static QCBORError
+DecodeNesting_Descend(QCBORDecodeNesting *pNesting, QCBORItem *pItem)
 {
    QCBORError nReturn = QCBOR_SUCCESS;
 
@@ -188,7 +200,8 @@
    return nReturn;;
 }
 
-inline static void DecodeNesting_Init(QCBORDecodeNesting *pNesting)
+inline static void
+DecodeNesting_Init(QCBORDecodeNesting *pNesting)
 {
    pNesting->pCurrent = &(pNesting->pMapsAndArrays[0]);
 }
@@ -260,10 +273,12 @@
 static inline int TagMapper_LookupBuiltIn(uint64_t uTag)
 {
    if(sizeof(spBuiltInTagMap)/sizeof(uint16_t) > TAG_MAPPER_MAX_SIZE_BUILT_IN_TAGS) {
-      // This is a cross-check to make sure the above array doesn't
-      // accidentally get made too big.
-      // In normal conditions the above test should optimize out
-      // as all the values are known at compile time.
+      /*
+       This is a cross-check to make sure the above array doesn't
+       accidentally get made too big.  In normal conditions the above
+       test should optimize out as all the values are known at compile
+       time.
+       */
       return -1;
    }
 
@@ -297,7 +312,10 @@
  This and the above functions could probably be optimized and made
  clearer and neater.
  */
-static QCBORError TagMapper_Lookup(const QCBORTagListIn *pCallerConfiguredTagMap, uint64_t uTag, uint8_t *puTagBitIndex)
+static QCBORError
+TagMapper_Lookup(const QCBORTagListIn *pCallerConfiguredTagMap,
+                 uint64_t uTag,
+                 uint8_t *puTagBitIndex)
 {
    int nTagBitIndex = TagMapper_LookupBuiltIn(uTag);
    if(nTagBitIndex >= 0) {
@@ -324,31 +342,38 @@
 
 
 
-/* ===========================================================================
+/*===========================================================================
    QCBORStringAllocate -- STRING ALLOCATOR INVOCATION
 
    The following four functions are pretty wrappers for invocation of
    the string allocator supplied by the caller.
 
- ==============================================================================*/
+  ===========================================================================*/
 
-static inline void StringAllocator_Free(const QCORInternalAllocator *pMe, void *pMem)
+static inline void
+StringAllocator_Free(const QCORInternalAllocator *pMe, void *pMem)
 {
    (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, 0);
 }
 
-// StringAllocator_Reallocate called with pMem NULL is equal to StringAllocator_Allocate()
-static inline UsefulBuf StringAllocator_Reallocate(const QCORInternalAllocator *pMe, void *pMem, size_t uSize)
+// StringAllocator_Reallocate called with pMem NULL is
+// equal to StringAllocator_Allocate()
+static inline UsefulBuf
+StringAllocator_Reallocate(const QCORInternalAllocator *pMe,
+                           void *pMem,
+                           size_t uSize)
 {
    return (pMe->pfAllocator)(pMe->pAllocateCxt, pMem, uSize);
 }
 
-static inline UsefulBuf StringAllocator_Allocate(const QCORInternalAllocator *pMe, size_t uSize)
+static inline UsefulBuf
+StringAllocator_Allocate(const QCORInternalAllocator *pMe, size_t uSize)
 {
    return (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, uSize);
 }
 
-static inline void StringAllocator_Destruct(const QCORInternalAllocator *pMe)
+static inline void
+StringAllocator_Destruct(const QCORInternalAllocator *pMe)
 {
    if(pMe->pfAllocator) {
       (pMe->pfAllocator)(pMe->pAllocateCxt, NULL, 0);
@@ -357,16 +382,22 @@
 
 
 
+/*===========================================================================
+ QCBORDecode -- The main implementation of CBOR decoding
 
+ See qcbor.h for definition of the object used here: QCBORDecodeContext
+  ===========================================================================*/
 /*
  Public function, see header file
  */
-void QCBORDecode_Init(QCBORDecodeContext *me, UsefulBufC EncodedCBOR, QCBORDecodeMode nDecodeMode)
+void QCBORDecode_Init(QCBORDecodeContext *me,
+                      UsefulBufC EncodedCBOR,
+                      QCBORDecodeMode nDecodeMode)
 {
    memset(me, 0, sizeof(QCBORDecodeContext));
    UsefulInputBuf_Init(&(me->InBuf), EncodedCBOR);
-   // Don't bother with error check on decode mode. If a bad value is passed it will just act as
-   // if the default normal mode of 0 was set.
+   // Don't bother with error check on decode mode. If a bad value is
+   // passed it will just act as if the default normal mode of 0 was set.
    me->uDecodeMode = nDecodeMode;
    DecodeNesting_Init(&(me->nesting));
 }
@@ -389,25 +420,31 @@
 /*
  Public function, see header file
  */
-void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *me, const QCBORTagListIn *pTagList)
+void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *me,
+                                            const QCBORTagListIn *pTagList)
 {
    me->pCallerConfiguredTagList = pTagList;
 }
 
 
 /*
- This decodes the fundamental part of a CBOR data item, the type and number
+ This decodes the fundamental part of a CBOR data item, the type and
+ number
 
  This is the Counterpart to InsertEncodedTypeAndNumber().
 
- This does the network->host byte order conversion. The conversion here
- also results in the conversion for floats in addition to that for
- lengths, tags and integer values.
+ This does the network->host byte order conversion. The conversion
+ here also results in the conversion for floats in addition to that
+ for lengths, tags and integer values.
 
  This returns:
    pnMajorType -- the major type for the item
-   puNumber -- the "number" which is used a the value for integers, tags and floats and length for strings and arrays
-   puAdditionalInfo -- Pass this along to know what kind of float or if length is indefinite
+
+   puNumber -- the "number" which is used a the value for integers,
+               tags and floats and length for strings and arrays
+
+   puAdditionalInfo -- Pass this along to know what kind of float or
+                       if length is indefinite
 
  */
 inline static QCBORError DecodeTypeAndNumber(UsefulInputBuf *pUInBuf,
@@ -428,8 +465,8 @@
    uint64_t uArgument;
 
    if(uAdditionalInfo >= LEN_IS_ONE_BYTE && uAdditionalInfo <= LEN_IS_EIGHT_BYTES) {
-      // Need to get 1,2,4 or 8 additional argument bytes
-      // Map LEN_IS_ONE_BYTE.. LEN_IS_EIGHT_BYTES to actual length
+      // Need to get 1,2,4 or 8 additional argument bytes Map
+      // LEN_IS_ONE_BYTE.. LEN_IS_EIGHT_BYTES to actual length
       static const uint8_t aIterate[] = {1,2,4,8};
 
       // Loop getting all the bytes in the argument
@@ -464,19 +501,20 @@
 }
 
 /*
- CBOR doesn't explicitly specify two's compliment for integers but all CPUs
- use it these days and the test vectors in the RFC are so. All integers in the CBOR
- structure are positive and the major type indicates positive or negative.
- CBOR can express positive integers up to 2^x - 1 where x is the number of bits
- and negative integers down to 2^x.  Note that negative numbers can be one
- more away from zero than positive.
- Stdint, as far as I can tell, uses two's compliment to represent
- negative integers.
+ CBOR doesn't explicitly specify two's compliment for integers but all
+ CPUs use it these days and the test vectors in the RFC are so. All
+ integers in the CBOR structure are positive and the major type
+ indicates positive or negative.  CBOR can express positive integers
+ up to 2^x - 1 where x is the number of bits and negative integers
+ down to 2^x.  Note that negative numbers can be one more away from
+ zero than positive.  Stdint, as far as I can tell, uses two's
+ compliment to represent negative integers.
 
  See http://www.unix.org/whitepapers/64bit.html for reasons int isn't
  used here in any way including in the interface
  */
-inline static QCBORError DecodeInteger(int nMajorType, uint64_t uNumber, QCBORItem *pDecodedItem)
+inline static QCBORError
+DecodeInteger(int nMajorType, uint64_t uNumber, QCBORItem *pDecodedItem)
 {
    // Stack usage: int/ptr 1 -- 8
    QCBORError nReturn = QCBOR_SUCCESS;
@@ -538,18 +576,19 @@
 /*
  Decode true, false, floats, break...
  */
-
-inline static QCBORError DecodeSimple(uint8_t uAdditionalInfo, uint64_t uNumber, QCBORItem *pDecodedItem)
+inline static QCBORError
+DecodeSimple(uint8_t uAdditionalInfo, uint64_t uNumber, QCBORItem *pDecodedItem)
 {
    // Stack usage: 0
    QCBORError nReturn = QCBOR_SUCCESS;
 
-   // uAdditionalInfo is 5 bits from the initial byte
-   // compile time checks above make sure uAdditionalInfo values line up with uDataType values
+   // uAdditionalInfo is 5 bits from the initial byte compile time checks
+   // above make sure uAdditionalInfo values line up with uDataType values
    pDecodedItem->uDataType = uAdditionalInfo;
 
    switch(uAdditionalInfo) {
-      // No check for ADDINFO_RESERVED1 - ADDINFO_RESERVED3 as it is caught before this is called.
+      // No check for ADDINFO_RESERVED1 - ADDINFO_RESERVED3 as they are
+      // caught before this is called.
 
       case HALF_PREC_FLOAT:
          pDecodedItem->val.dfnum = IEEE754_HalfToDouble((uint16_t)uNumber);
@@ -582,8 +621,12 @@
 
       default: // 0-19
          pDecodedItem->uDataType   = QCBOR_TYPE_UKNOWN_SIMPLE;
-         // DecodeTypeAndNumber will make uNumber equal to uAdditionalInfo when uAdditionalInfo is < 24
-         // This cast is safe because the 2, 4 and 8 byte lengths of uNumber are in the double/float cases above
+         /*
+          DecodeTypeAndNumber will make uNumber equal to
+          uAdditionalInfo when uAdditionalInfo is < 24 This cast is
+          safe because the 2, 4 and 8 byte lengths of uNumber are in
+          the double/float cases above
+          */
          pDecodedItem->val.uSimple = (uint8_t)uNumber;
          break;
    }
@@ -626,7 +669,9 @@
       // Normal case with no string allocator
       pDecodedItem->val.string = Bytes;
    }
-   pDecodedItem->uDataType  = (nMajorType == CBOR_MAJOR_TYPE_BYTE_STRING) ? QCBOR_TYPE_BYTE_STRING : QCBOR_TYPE_TEXT_STRING;
+   const bool bIsBstr = (nMajorType == CBOR_MAJOR_TYPE_BYTE_STRING);
+   pDecodedItem->uDataType  = bIsBstr ? QCBOR_TYPE_BYTE_STRING
+                                      : QCBOR_TYPE_TEXT_STRING;
 
 Done:
    return nReturn;
@@ -638,7 +683,8 @@
 
 
 
-// Make sure the constants align as this is assumed by the GetAnItem() implementation
+// Make sure the constants align as this is assumed by
+// the GetAnItem() implementation
 #if QCBOR_TYPE_ARRAY != CBOR_MAJOR_TYPE_ARRAY
 #error QCBOR_TYPE_ARRAY value not lined up with major type
 #endif
@@ -647,12 +693,13 @@
 #endif
 
 /*
- This gets a single data item and decodes it including preceding optional tagging. This does not
- deal with arrays and maps and nesting except to decode the data item introducing them. Arrays and
- maps are handled at the next level up in GetNext().
+ This gets a single data item and decodes it including preceding
+ optional tagging. This does not deal with arrays and maps and nesting
+ except to decode the data item introducing them. Arrays and maps are
+ handled at the next level up in GetNext().
 
- Errors detected here include: an array that is too long to decode, hit end of buffer unexpectedly,
-    a few forms of invalid encoded CBOR
+ Errors detected here include: an array that is too long to decode,
+ hit end of buffer unexpectedly, a few forms of invalid encoded CBOR
  */
 static QCBORError GetNext_Item(UsefulInputBuf *pUInBuf,
                                QCBORItem *pDecodedItem,
@@ -661,8 +708,12 @@
    // Stack usage: int/ptr 3 -- 24
    QCBORError nReturn;
 
-   // Get the major type and the number. Number could be length of more bytes or the value depending on the major type
-   // nAdditionalInfo is an encoding of the length of the uNumber and is needed to decode floats and doubles
+   /*
+    Get the major type and the number. Number could be length of more
+    bytes or the value depending on the major type nAdditionalInfo is
+    an encoding of the length of the uNumber and is needed to decode
+    floats and doubles
+   */
    int      uMajorType;
    uint64_t uNumber;
    uint8_t  uAdditionalInfo;
@@ -671,14 +722,14 @@
 
    nReturn = DecodeTypeAndNumber(pUInBuf, &uMajorType, &uNumber, &uAdditionalInfo);
 
-   // Error out here if we got into trouble on the type and number.
-   // The code after this will not work if the type and number is not good.
+   // Error out here if we got into trouble on the type and number.  The
+   // code after this will not work if the type and number is not good.
    if(nReturn) {
       goto Done;
    }
 
-   // At this point the major type and the value are valid. We've got the type and the number that
-   // starts every CBOR data item.
+   // At this point the major type and the value are valid. We've got
+   // the type and the number that starts every CBOR data item.
    switch (uMajorType) {
       case CBOR_MAJOR_TYPE_POSITIVE_INT: // Major type 0
       case CBOR_MAJOR_TYPE_NEGATIVE_INT: // Major type 1
@@ -692,7 +743,9 @@
       case CBOR_MAJOR_TYPE_BYTE_STRING: // Major type 2
       case CBOR_MAJOR_TYPE_TEXT_STRING: // Major type 3
          if(uAdditionalInfo == LEN_IS_INDEFINITE) {
-            pDecodedItem->uDataType  = (uMajorType == CBOR_MAJOR_TYPE_BYTE_STRING) ? QCBOR_TYPE_BYTE_STRING : QCBOR_TYPE_TEXT_STRING;
+            const bool bIsBstr = (uMajorType == CBOR_MAJOR_TYPE_BYTE_STRING);
+            pDecodedItem->uDataType = bIsBstr ? QCBOR_TYPE_BYTE_STRING
+                                              : QCBOR_TYPE_TEXT_STRING;
             pDecodedItem->val.string = (UsefulBufC){NULL, SIZE_MAX};
          } else {
             nReturn = DecodeBytes(pAllocator, uMajorType, uNumber, pUInBuf, pDecodedItem);
@@ -709,9 +762,11 @@
          if(uAdditionalInfo == LEN_IS_INDEFINITE) {
             pDecodedItem->val.uCount = UINT16_MAX; // Indicate indefinite length
          } else {
-            pDecodedItem->val.uCount = (uint16_t)uNumber; // type conversion OK because of check above
+            // type conversion OK because of check above
+            pDecodedItem->val.uCount = (uint16_t)uNumber;
          }
-         pDecodedItem->uDataType  = uMajorType; // C preproc #if above makes sure constants align
+         // C preproc #if above makes sure constants for major types align
+         pDecodedItem->uDataType  = uMajorType;
          break;
 
       case CBOR_MAJOR_TYPE_OPTIONAL: // Major type 6, optional prepended tags
@@ -723,11 +778,13 @@
          }
          break;
 
-      case CBOR_MAJOR_TYPE_SIMPLE: // Major type 7, float, double, true, false, null...
+      case CBOR_MAJOR_TYPE_SIMPLE:
+         // Major type 7, float, double, true, false, null...
          nReturn = DecodeSimple(uAdditionalInfo, uNumber, pDecodedItem);
          break;
 
-      default: // Should never happen because DecodeTypeAndNumber() should never return > 7
+      default:
+         // Never happens because DecodeTypeAndNumber() should never return > 7
          nReturn = QCBOR_ERR_UNSUPPORTED;
          break;
    }
@@ -740,12 +797,13 @@
 
 /*
  This layer deals with indefinite length strings. It pulls all the
- individual chunk items together into one QCBORItem using the
- string allocator.
+ individual chunk items together into one QCBORItem using the string
+ allocator.
 
  Code Reviewers: THIS FUNCTION DOES A LITTLE POINTER MATH
  */
-static inline QCBORError GetNext_FullItem(QCBORDecodeContext *me, QCBORItem *pDecodedItem)
+static inline QCBORError
+GetNext_FullItem(QCBORDecodeContext *me, QCBORItem *pDecodedItem)
 {
    // Stack usage; int/ptr 2 UsefulBuf 2 QCBORItem  -- 96
    QCBORError nReturn;
@@ -842,7 +900,10 @@
  Gets all optional tag data items preceding a data item that is not an
  optional tag and records them as bits in the tag map.
  */
-static QCBORError GetNext_TaggedItem(QCBORDecodeContext *me, QCBORItem *pDecodedItem, QCBORTagListOut *pTags)
+static QCBORError
+GetNext_TaggedItem(QCBORDecodeContext *me,
+                   QCBORItem *pDecodedItem,
+                   QCBORTagListOut *pTags)
 {
    // Stack usage: int/ptr: 3 -- 24
    QCBORError nReturn;
@@ -899,9 +960,13 @@
 
 
 /*
- This layer takes care of map entries. It combines the label and data items into one QCBORItem.
+ This layer takes care of map entries. It combines the label and data
+ items into one QCBORItem.
  */
-static inline QCBORError GetNext_MapEntry(QCBORDecodeContext *me, QCBORItem *pDecodedItem, QCBORTagListOut *pTags)
+static inline QCBORError
+GetNext_MapEntry(QCBORDecodeContext *me,
+                 QCBORItem *pDecodedItem,
+                 QCBORTagListOut *pTags)
 {
    // Stack use: int/ptr 1, QCBORItem  -- 56
    QCBORError nReturn = GetNext_TaggedItem(me, pDecodedItem, pTags);
@@ -919,7 +984,8 @@
       if(DecodeNesting_TypeIsMap(&(me->nesting))) {
          // If in a map and the right decoding mode, get the label
 
-         // Get the next item which will be the real data; Item will be the label
+         // Save label in pDecodedItem and get the next which will
+         // be the real data
          QCBORItem LabelItem = *pDecodedItem;
          nReturn = GetNext_TaggedItem(me, pDecodedItem, pTags);
          if(nReturn)
@@ -932,7 +998,7 @@
             pDecodedItem->label.string = LabelItem.val.string;
             pDecodedItem->uLabelType = QCBOR_TYPE_TEXT_STRING;
          } else if (QCBOR_DECODE_MODE_MAP_STRINGS_ONLY == me->uDecodeMode) {
-            // It's not a string and we only want strings, probably for easy translation to JSON
+            // It's not a string and we only want strings
             nReturn = QCBOR_ERR_MAP_LABEL_TYPE;
             goto Done;
          } else if(LabelItem.uDataType == QCBOR_TYPE_INT64) {
@@ -969,7 +1035,9 @@
 /*
  Public function, see header qcbor.h file
  */
-QCBORError QCBORDecode_GetNextMapOrArray(QCBORDecodeContext *me, QCBORItem *pDecodedItem, QCBORTagListOut *pTags)
+QCBORError QCBORDecode_GetNextMapOrArray(QCBORDecodeContext *me,
+                                         QCBORItem *pDecodedItem,
+                                         QCBORTagListOut *pTags)
 {
    // Stack ptr/int: 2, QCBORItem : 64
 
@@ -1092,13 +1160,15 @@
    }
    const UsefulBufC Temp    = pDecodedItem->val.string;
    pDecodedItem->val.bigNum = Temp;
-   pDecodedItem->uDataType  = pDecodedItem->uTagBits & QCBOR_TAGFLAG_POS_BIGNUM ? QCBOR_TYPE_POSBIGNUM : QCBOR_TYPE_NEGBIGNUM;
+   const bool bIsPosBigNum = (bool)(pDecodedItem->uTagBits & QCBOR_TAGFLAG_POS_BIGNUM);
+   pDecodedItem->uDataType  = bIsPosBigNum ? QCBOR_TYPE_POSBIGNUM : QCBOR_TYPE_NEGBIGNUM;
    return QCBOR_SUCCESS;
 }
 
 
 /*
- The epoch formatted date. Turns lots of different forms of encoding date into uniform one
+ The epoch formatted date. Turns lots of different forms of encoding
+ date into uniform one
  */
 static int DecodeDateEpoch(QCBORItem *pDecodedItem)
 {
@@ -1187,9 +1257,9 @@
    }
 
    // A check for pDecodedItem->val.uCount == 2 would work for
-   //   definite length arrays, but not for indefnite.  Instead remember
-   //   the nesting level the two integers must be at, which is one
-   //   deeper than that of the array.
+   // definite length arrays, but not for indefnite.  Instead remember
+   // the nesting level the two integers must be at, which is one
+   // deeper than that of the array.
    const int nNestLevel = pDecodedItem->uNestingLevel + 1;
 
    // --- Is it a decimal fraction or a bigfloat? ---
@@ -1266,7 +1336,10 @@
 /*
  Public function, see header qcbor.h file
  */
-QCBORError QCBORDecode_GetNextWithTags(QCBORDecodeContext *me, QCBORItem *pDecodedItem, QCBORTagListOut *pTags)
+QCBORError
+QCBORDecode_GetNextWithTags(QCBORDecodeContext *me,
+                            QCBORItem *pDecodedItem,
+                            QCBORTagListOut *pTags)
 {
    QCBORError nReturn;
 
@@ -1383,7 +1456,9 @@
 /*
  Public function, see header qcbor.h file
  */
-int QCBORDecode_IsTagged(QCBORDecodeContext *me, const QCBORItem *pItem, uint64_t uTag)
+int QCBORDecode_IsTagged(QCBORDecodeContext *me,
+                         const QCBORItem *pItem,
+                         uint64_t uTag)
 {
    const QCBORTagListIn *pCallerConfiguredTagMap = me->pCallerConfiguredTagList;
 
@@ -1431,21 +1506,28 @@
 
 Decoder errors handled in this file
 
- - Hit end of input before it was expected while decoding type and number QCBOR_ERR_HIT_END
+ - Hit end of input before it was expected while decoding type and
+   number QCBOR_ERR_HIT_END
 
  - negative integer that is too large for C QCBOR_ERR_INT_OVERFLOW
 
- - Hit end of input while decoding a text or byte string QCBOR_ERR_HIT_END
+ - Hit end of input while decoding a text or byte string
+   QCBOR_ERR_HIT_END
 
- - Encountered conflicting tags -- e.g., an item is tagged both a date string and an epoch date QCBOR_ERR_UNSUPPORTED
+ - Encountered conflicting tags -- e.g., an item is tagged both a date
+   string and an epoch date QCBOR_ERR_UNSUPPORTED
 
- - Encontered an array or mapp that has too many items QCBOR_ERR_ARRAY_TOO_LONG
+ - Encontered an array or mapp that has too many items
+   QCBOR_ERR_ARRAY_TOO_LONG
 
- - Encountered array/map nesting that is too deep QCBOR_ERR_ARRAY_NESTING_TOO_DEEP
+ - Encountered array/map nesting that is too deep
+   QCBOR_ERR_ARRAY_NESTING_TOO_DEEP
 
- - An epoch date > INT64_MAX or < INT64_MIN was encountered QCBOR_ERR_DATE_OVERFLOW
+ - An epoch date > INT64_MAX or < INT64_MIN was encountered
+   QCBOR_ERR_DATE_OVERFLOW
 
- - The type of a map label is not a string or int QCBOR_ERR_MAP_LABEL_TYPE
+ - The type of a map label is not a string or int
+   QCBOR_ERR_MAP_LABEL_TYPE
 
  - Hit end with arrays or maps still open -- QCBOR_ERR_EXTRA_BYTES
 
@@ -1478,15 +1560,17 @@
 
    The sizes packed in are uint32_t to be the same on all CPU types
    and simplify the code.
-   =========================================================================== */
+   ========================================================================== */
 
 
-static inline int MemPool_Unpack(const void *pMem, uint32_t *puPoolSize, uint32_t *puFreeOffset)
+static inline int
+MemPool_Unpack(const void *pMem, uint32_t *puPoolSize, uint32_t *puFreeOffset)
 {
    // Use of UsefulInputBuf is overkill, but it is convenient.
    UsefulInputBuf UIB;
 
-   // Just assume the size here. It was checked during SetUp so the assumption is safe.
+   // Just assume the size here. It was checked during SetUp so
+   // the assumption is safe.
    UsefulInputBuf_Init(&UIB, (UsefulBufC){pMem, QCBOR_DECODE_MIN_MEM_POOL_SIZE});
    *puPoolSize     = UsefulInputBuf_GetUint32(&UIB);
    *puFreeOffset   = UsefulInputBuf_GetUint32(&UIB);
@@ -1494,7 +1578,8 @@
 }
 
 
-static inline int MemPool_Pack(UsefulBuf Pool, uint32_t uFreeOffset)
+static inline int
+MemPool_Pack(UsefulBuf Pool, uint32_t uFreeOffset)
 {
    // Use of UsefulOutBuf is overkill, but convenient. The
    // length check performed here is useful.
@@ -1515,7 +1600,8 @@
 
  Code Reviewers: THIS FUNCTION DOES POINTER MATH
  */
-static UsefulBuf MemPool_Function(void *pPool, void *pMem, size_t uNewSize)
+static UsefulBuf
+MemPool_Function(void *pPool, void *pMem, size_t uNewSize)
 {
    UsefulBuf ReturnValue = NULLUsefulBuf;
 
@@ -1599,7 +1685,9 @@
 /*
  Public function, see header qcbor.h file
  */
-QCBORError QCBORDecode_SetMemPool(QCBORDecodeContext *pMe, UsefulBuf Pool, bool bAllStrings)
+QCBORError QCBORDecode_SetMemPool(QCBORDecodeContext *pMe,
+                                  UsefulBuf Pool,
+                                  bool bAllStrings)
 {
    // The pool size and free mem offset are packed into the beginning
    // of the pool memory. This compile time check make sure the
diff --git a/src/qcbor_encode.c b/src/qcbor_encode.c
index 56114e1..cb6670d 100644
--- a/src/qcbor_encode.c
+++ b/src/qcbor_encode.c
@@ -1,6 +1,6 @@
 /*==============================================================================
  Copyright (c) 2016-2018, The Linux Foundation.
- Copyright (c) 2018-2019, Laurence Lundblade.
+ Copyright (c) 2018-2020, Laurence Lundblade.
  All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -28,9 +28,9 @@
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- ==============================================================================*/
+ =============================================================================*/
 
-/*===================================================================================
+/*=============================================================================
  FILE:  qcbor_encode.c
 
  DESCRIPTION:  This file contains the implementation of QCBOR.
@@ -40,54 +40,64 @@
  This section contains comments describing changes made to the module.
  Notice that changes are listed in reverse chronological order.
 
- when               who             what, where, why
- --------           ----            ---------------------------------------------------
- 12/30/19           llundblade      Add support for decimal fractions and bigfloats.
- 8/7/19             llundblade      Prevent encoding simple type reserved values 24..31
- 7/25/19            janjongboom     Add indefinite length encoding for maps and arrays
- 4/6/19             llundblade      Wrapped bstr returned now includes the wrapping bstr
- 12/30/18           llundblade      Small efficient clever encode of type & argument.
- 11/29/18           llundblade      Rework to simpler handling of tags and labels.
- 11/9/18            llundblade      Error codes are now enums.
- 11/1/18            llundblade      Floating support.
- 10/31/18           llundblade      Switch to one license that is almost BSD-3.
- 09/28/18           llundblade      Added bstr wrapping feature for COSE implementation.
- 02/05/18           llundbla        Works on CPUs which require integer alignment.
-                                    Requires new version of UsefulBuf.
- 07/05/17           llundbla        Add bstr wrapping of maps/arrays for COSE
- 03/01/17           llundbla        More data types
- 11/13/16           llundbla        Integrate most TZ changes back into github version.
- 09/30/16           gkanike         Porting to TZ.
- 03/15/16           llundbla        Initial Version.
+ when       who             what, where, why
+ --------   ----            ---------------------------------------------------
+ 01/08/2020 llundblade      Documentation corrections & improved code formatting.
+ 12/30/19   llundblade      Add support for decimal fractions and bigfloats.
+ 8/7/19     llundblade      Prevent encoding simple type reserved values 24..31
+ 7/25/19    janjongboom     Add indefinite length encoding for maps and arrays
+ 4/6/19     llundblade      Wrapped bstr returned now includes the wrapping bstr
+ 12/30/18   llundblade      Small efficient clever encode of type & argument.
+ 11/29/18   llundblade      Rework to simpler handling of tags and labels.
+ 11/9/18    llundblade      Error codes are now enums.
+ 11/1/18    llundblade      Floating support.
+ 10/31/18   llundblade      Switch to one license that is almost BSD-3.
+ 09/28/18   llundblade      Added bstr wrapping feature for COSE implementation.
+ 02/05/18   llundbla        Works on CPUs which require integer alignment.
+                            Requires new version of UsefulBuf.
+ 07/05/17   llundbla        Add bstr wrapping of maps/arrays for COSE
+ 03/01/17   llundbla        More data types
+ 11/13/16   llundbla        Integrate most TZ changes back into github version.
+ 09/30/16   gkanike         Porting to TZ.
+ 03/15/16   llundbla        Initial Version.
 
- =====================================================================================*/
+ =============================================================================*/
 
 #include "qcbor.h"
 #include "ieee754.h"
 
 
-/*...... This is a ruler that is 80 characters long...........................*/
-
 
 /*
- CBOR's two nesting types, arrays and maps, are tracked here. There is a
- limit of QCBOR_MAX_ARRAY_NESTING to the number of arrays and maps
+ Nesting -- This tracks the nesting of maps and arrays.
+
+ The following functions and data type QCBORTrackNesting implement the
+ nesting management for encoding.
+
+ CBOR's two nesting types, arrays and maps, are tracked here. There is
+ a limit of QCBOR_MAX_ARRAY_NESTING to the number of arrays and maps
  that can be nested in one encoding so the encoding context stays
  small enough to fit on the stack.
 
  When an array / map is opened, pCurrentNesting points to the element
- in pArrays that records the type, start position and accumluates a
+ in pArrays that records the type, start position and accumulates a
  count of the number of items added. When closed the start position is
  used to go back and fill in the type and number of items in the array
  / map.
 
- Encoded output be just items like ints and strings that are
- not part of any array / map. That is, the first thing encoded
- does not have to be an array or a map.
+ Encoded output can be just items like ints and strings that are not
+ part of any array / map. That is, the first thing encoded does not
+ have to be an array or a map.
+
+ QCBOR has a special feature to allow constructing bstr-wrapped CBOR
+ directly into the output buffer, so an extra buffer for it is not
+ needed.  This is implemented as nesting with type
+ CBOR_MAJOR_TYPE_BYTE_STRING and uses this code. Bstr-wrapped CBOR is
+ used by COSE for data that is to be hashed.
  */
 inline static void Nesting_Init(QCBORTrackNesting *pNesting)
 {
-   // assumes pNesting has been zeroed
+   // Assumes pNesting has been zeroed
    pNesting->pCurrentNesting = &pNesting->pArrays[0];
    // Implied CBOR array at the top nesting level. This is never returned,
    // but makes the item count work correctly.
@@ -101,7 +111,7 @@
    QCBORError nReturn = QCBOR_SUCCESS;
 
    if(pNesting->pCurrentNesting == &pNesting->pArrays[QCBOR_MAX_ARRAY_NESTING]) {
-      // trying to open one too many
+      // Trying to open one too many
       nReturn = QCBOR_ERR_ARRAY_NESTING_TOO_DEEP;
    } else {
       pNesting->pCurrentNesting++;
@@ -152,17 +162,35 @@
    return pNesting->pCurrentNesting->uMajorType;
 }
 
-inline static int Nesting_IsInNest(QCBORTrackNesting *pNesting)
+inline static bool Nesting_IsInNest(QCBORTrackNesting *pNesting)
 {
-   return pNesting->pCurrentNesting == &pNesting->pArrays[0] ? 0 : 1;
+   return pNesting->pCurrentNesting == &pNesting->pArrays[0] ? false : true;
 }
 
 
 
 
 /*
+ Encoding of the major CBOR types is by these functions:
+
+ CBOR Major Type    Public Function
+ 0                  QCBOREncode_AddUInt64()
+ 0, 1               QCBOREncode_AddUInt64(), QCBOREncode_AddInt64()
+ 2, 3               QCBOREncode_AddBuffer(), Also QCBOREncode_OpenMapOrArray(),
+                    QCBOREncode_CloseMapOrArray()
+ 4, 5               QCBOREncode_OpenMapOrArray(), QCBOREncode_CloseMapOrArray(),
+                    QCBOREncode_OpenMapOrArrayIndefiniteLength(),
+                    QCBOREncode_CloseMapOrArrayIndefiniteLength()
+ 6                  QCBOREncode_AddTag()
+ 7                  QCBOREncode_AddDouble(), QCBOREncode_AddType7()
+
+ Additionally, encoding of decimal fractions and bigfloats is by
+ QCBOREncode_AddExponentAndMantissa()
+*/
+
+/*
  Error tracking plan -- Errors are tracked internally and not returned
- until Finish is called. The CBOR errors are in me->uError.
+ until QCBOREncode_Finish is called. The CBOR errors are in me->uError.
  UsefulOutBuf also tracks whether the buffer is full or not in its
  context.  Once either of these errors is set they are never
  cleared. Only QCBOREncode_Init() resets them. Or said another way, they must
@@ -191,27 +219,24 @@
  structures like array/map nesting resulting in some stack memory
  savings.
 
- Errors returned here fall into three categories:
+ The 8 errors returned here fall into three categories:
 
  Sizes
-   QCBOR_ERR_BUFFER_TOO_LARGE -- Encoded output exceeded UINT32_MAX
-   QCBOR_ERR_BUFFER_TOO_SMALL -- output buffer too small
-
-   QCBOR_ERR_ARRAY_NESTING_TOO_DEEP -- Array/map nesting > QCBOR_MAX_ARRAY_NESTING1
-   QCBOR_ERR_ARRAY_TOO_LONG -- Too many things added to an array/map
+   QCBOR_ERR_BUFFER_TOO_LARGE        -- Encoded output exceeded UINT32_MAX
+   QCBOR_ERR_BUFFER_TOO_SMALL        -- Output buffer too small
+   QCBOR_ERR_ARRAY_NESTING_TOO_DEEP  -- Nesting > QCBOR_MAX_ARRAY_NESTING1
+   QCBOR_ERR_ARRAY_TOO_LONG          -- Too many things added to an array/map
 
  Nesting constructed incorrectly
-   QCBOR_ERR_TOO_MANY_CLOSES -- more close calls than opens
-   QCBOR_ERR_CLOSE_MISMATCH -- Type of close does not match open
+   QCBOR_ERR_TOO_MANY_CLOSES         -- More close calls than opens
+   QCBOR_ERR_CLOSE_MISMATCH          -- Type of close does not match open
    QCBOR_ERR_ARRAY_OR_MAP_STILL_OPEN -- Finish called without enough closes
 
  Would generate not-well-formed CBOR
-   QCBOR_ERR_UNSUPPORTED -- Simple type between 24 and 31
+   QCBOR_ERR_UNSUPPORTED             -- Simple type between 24 and 31
  */
 
 
-
-
 /*
  Public function for initialization. See header qcbor.h
  */
@@ -223,9 +248,18 @@
 }
 
 
+/**
+ @brief Encode a data item, the most atomic part of CBOR
 
+ @param[in,out] me      Encoding context including output buffer
+ @param[in] uMajorType  One of CBOR_MAJOR_TYPE_XX
+ @param[in] nMinLen     Include zero bytes up to this length. If 0 include
+                        no zero bytes. Non-zero to encode floats and doubles.
+ @param[in] uNumber     The number to encode, the argument.
+ @param[in] uPos        The position in the output buffer (which is inside
+                        the encoding context) to insert the result. This is
+                        usually at the end, an append.
 
-/*
  All CBOR data items have a type and an "argument". The argument is
  either the value of the item for integer types, the length of the
  content for string, byte, array and map types, a tag for major type
@@ -264,17 +298,15 @@
  This function is also used to insert floats and doubles. Before this
  function is called the float or double must be copied into a
  uint64_t. That is how they are passed in. They are then converted to
- network byte order correctly. The uMinLen param makes sure that even
-
- if all the digits of a half, float or double are 0 it is still
+ network byte order correctly. The uMinLen parameter makes sure that
+ even if all the digits of a half, float or double are 0 it is still
  correctly encoded in 2, 4 or 8 bytes.
  */
-
 static void InsertEncodedTypeAndNumber(QCBOREncodeContext *me,
-                                       uint8_t uMajorType,
-                                       int nMinLen,
-                                       uint64_t uNumber,
-                                       size_t uPos)
+                                       uint8_t             uMajorType,
+                                       int                 nMinLen,
+                                       uint64_t            uNumber,
+                                       size_t              uPos)
 {
    /*
     This code does endian conversion without hton or knowing the
@@ -297,9 +329,9 @@
 
     Code Reviewers: THIS FUNCTION DOES POINTER MATH
     */
-   // Holds up to 9 bytes of type and argument
-   // plus one extra so pointer always points to
-   // valid bytes.
+
+   // Holds up to 9 bytes of type and argument plus one extra so pointer
+   // always points to valid bytes.
    uint8_t bytes[sizeof(uint64_t)+2];
    // Point to the last bytes and work backwards
    uint8_t *pByte = &bytes[sizeof(bytes)-1];
@@ -320,15 +352,13 @@
       uAdditionalInfo = uNumber;
    } else  {
       /*
-       Encode argument in 1,2,4 or 8 bytes. Outer loop
-       runs once for 1 byte and 4 times for 8 bytes.
-       Inner loop runs 1, 2 or 4 times depending on
-       outer loop counter. This works backwards taking
-       8 bits off the argument being encoded at a time
-       until all bits from uNumber have been encoded
-       and the minimum encoding size is reached.
-       Minimum encoding size is for floating point
-       numbers with zero bytes.
+       Encode argument in 1,2,4 or 8 bytes. Outer loop runs once for 1
+       byte and 4 times for 8 bytes.  Inner loop runs 1, 2 or 4 times
+       depending on outer loop counter. This works backwards taking 8
+       bits off the argument being encoded at a time until all bits
+       from uNumber have been encoded and the minimum encoding size is
+       reached.  Minimum encoding size is for floating-point numbers
+       with zero bytes.
        */
       static const uint8_t aIterate[] = {1,1,2,4};
       uint8_t i;
@@ -340,9 +370,8 @@
          }
          nMinLen -= uIterations;
       }
-      // Additional info is the encoding of the
-      // number of additional bytes to encode
-      // argument.
+      // Additional info is the encoding of the number of additional
+      // bytes to encode argument.
       uAdditionalInfo = LEN_IS_ONE_BYTE-1 + i;
    }
    *--pByte = (uMajorType << 5) + uAdditionalInfo;
@@ -354,7 +383,7 @@
 /*
  Append the type and number info to the end of the buffer.
 
- See InsertEncodedTypeAndNumber() function above for details
+ See InsertEncodedTypeAndNumber() function above for details.
 */
 inline static void AppendEncodedTypeAndNumber(QCBOREncodeContext *me,
                                               uint8_t uMajorType,
@@ -372,7 +401,7 @@
 
 
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
 void QCBOREncode_AddUInt64(QCBOREncodeContext *me, uint64_t uValue)
 {
@@ -384,7 +413,7 @@
 
 
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
 void QCBOREncode_AddInt64(QCBOREncodeContext *me, int64_t nNum)
 {
@@ -411,7 +440,7 @@
  Semi-private function. It is exposed to user of the interface, but
  they will usually call one of the inline wrappers rather than this.
 
- See header qcbor.h
+ See qcbor.h
 
  Does the work of adding actual strings bytes to the CBOR output (as
  opposed to numbers and opening / closing aggregate types).
@@ -451,7 +480,7 @@
 
 
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
 void QCBOREncode_AddTag(QCBOREncodeContext *me, uint64_t uTag)
 {
@@ -471,13 +500,14 @@
       if(uNum >= CBOR_SIMPLEV_RESERVED_START && uNum <= CBOR_SIMPLEV_RESERVED_END) {
          me->uError = QCBOR_ERR_UNSUPPORTED;
       } else {
-         // This function call takes care of endian swapping for the float / double
+         // This call takes care of endian swapping for the float / double
          InsertEncodedTypeAndNumber(me,
                                     // The major type for floats and doubles
                                     CBOR_MAJOR_TYPE_SIMPLE,
-                                    // size makes sure floats with zeros encode correctly
+                                    // Must pass size to ensure floats
+                                    // with zero bytes encode correctly
                                     (int)uSize,
-                                    // Bytes of the floating point number as a uint
+                                    // The floating-point number as a uint
                                     uNum,
                                     // end position because this is append
                                     UsefulOutBuf_GetEndPosition(&(me->OutBuf)));
@@ -489,7 +519,7 @@
 
 
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
 void QCBOREncode_AddDouble(QCBOREncodeContext *me, double dNum)
 {
@@ -513,12 +543,13 @@
                                         int64_t             nMantissa,
                                         int64_t             nExponent)
 {
-
-   // This is for encoding either a big float or a decimal fraction,
-   // both of which are an array of two items, an exponent and a
-   // mantissa.  The difference between the two is that the exponent is
-   // base-2 for big floats and base-10 for decimal fractions, but that
-   // has no effect on the code here.
+   /*
+    This is for encoding either a big float or a decimal fraction,
+    both of which are an array of two items, an exponent and a
+    mantissa.  The difference between the two is that the exponent is
+    base-2 for big floats and base-10 for decimal fractions, but that
+    has no effect on the code here.
+    */
    QCBOREncode_AddTag(pMe, uTag);
    QCBOREncode_OpenArray(pMe);
    QCBOREncode_AddInt64(pMe, nExponent);
@@ -547,25 +578,30 @@
    // Add one item to the nesting level we are in for the new map or array
    me->uError = Nesting_Increment(&(me->nesting));
    if(me->uError == QCBOR_SUCCESS) {
-      // The offset where the length of an array or map will get written
-      // is stored in a uint32_t, not a size_t to keep stack usage smaller. This
-      // checks to be sure there is no wrap around when recording the offset.
-      // Note that on 64-bit machines CBOR larger than 4GB can be encoded as long as no
-      // array / map offsets occur past the 4GB mark, but the public interface
-      // says that the maximum is 4GB to keep the discussion simpler.
+      /*
+       The offset where the length of an array or map will get written
+       is stored in a uint32_t, not a size_t to keep stack usage
+       smaller. This checks to be sure there is no wrap around when
+       recording the offset.  Note that on 64-bit machines CBOR larger
+       than 4GB can be encoded as long as no array / map offsets occur
+       past the 4GB mark, but the public interface says that the
+       maximum is 4GB to keep the discussion simpler.
+      */
       size_t uEndPosition = UsefulOutBuf_GetEndPosition(&(me->OutBuf));
 
-      // QCBOR_MAX_ARRAY_OFFSET is slightly less than UINT32_MAX so this
-      // code can run on a 32-bit machine and tests can pass on a 32-bit
-      // machine. If it was exactly UINT32_MAX, then this code would
-      // not compile or run on a 32-bit machine and an #ifdef or some
-      // machine size detection would be needed reducing portability.
+      /*
+       QCBOR_MAX_ARRAY_OFFSET is slightly less than UINT32_MAX so this
+       code can run on a 32-bit machine and tests can pass on a 32-bit
+       machine. If it was exactly UINT32_MAX, then this code would not
+       compile or run on a 32-bit machine and an #ifdef or some
+       machine size detection would be needed reducing portability.
+      */
       if(uEndPosition >= QCBOR_MAX_ARRAY_OFFSET) {
          me->uError = QCBOR_ERR_BUFFER_TOO_LARGE;
 
       } else {
-         // Increase nesting level because this is a map or array.
-         // Cast from size_t to uin32_t is safe because of check above
+         // Increase nesting level because this is a map or array.  Cast
+         // from size_t to uin32_t is safe because of check above
          me->uError = Nesting_Increase(&(me->nesting), uMajorType, (uint32_t)uEndPosition);
       }
    }
@@ -576,7 +612,7 @@
  Semi-public function. It is exposed to user of the interface,
  but they will usually call one of the inline wrappers rather than this.
 
- See header qcbor.h
+ See qcbor.h
 */
 void QCBOREncode_OpenMapOrArrayIndefiniteLength(QCBOREncodeContext *me, uint8_t uMajorType)
 {
@@ -586,8 +622,9 @@
    QCBOREncode_OpenMapOrArray(me, uMajorType);
 }
 
+
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
 void QCBOREncode_CloseMapOrArray(QCBOREncodeContext *me,
                                  uint8_t uMajorType,
@@ -599,36 +636,46 @@
       } else if(Nesting_GetMajorType(&(me->nesting)) != uMajorType) {
          me->uError = QCBOR_ERR_CLOSE_MISMATCH;
       } else {
-         // When the array, map or bstr wrap was started, nothing was done
-         // except note the position of the start of it. This code goes back
-         // and inserts the actual CBOR array, map or bstr and its length.
-         // That means all the data that is in the array, map or wrapped
-         // needs to be slid to the right. This is done by UsefulOutBuf's
-         // insert function that is called from inside
-         // InsertEncodedTypeAndNumber()
-         const size_t uInsertPosition         = Nesting_GetStartPos(&(me->nesting));
-         const size_t uEndPosition            = UsefulOutBuf_GetEndPosition(&(me->OutBuf));
-         // This can't go negative because the UsefulOutBuf always only grows
-         // and never shrinks. UsefulOutBut itself also has defenses such that
-         // it won't write were it should not even if given hostile input lengths
+         /*
+          When the array, map or bstr wrap was started, nothing was
+          gone except note the position of the start of it. This code
+          goes back and inserts the actual CBOR array, map or bstr and
+          its length.  That means all the data that is in the array,
+          map or wrapped needs to be slid to the right. This is done
+          by UsefulOutBuf's insert function that is called from inside
+          InsertEncodedTypeAndNumber()
+          */
+         const size_t uInsertPosition = Nesting_GetStartPos(&(me->nesting));
+         const size_t uEndPosition    = UsefulOutBuf_GetEndPosition(&(me->OutBuf));
+         /*
+          This can't go negative because the UsefulOutBuf always only
+          grows and never shrinks. UsefulOutBut itself also has
+          defenses such that it won't write were it should not even if
+          given hostile input lengths
+          */
          const size_t uLenOfEncodedMapOrArray = uEndPosition - uInsertPosition;
 
-         // Length is number of bytes for a bstr and number of items a for map & array
-         const size_t uLength = uMajorType == CBOR_MAJOR_TYPE_BYTE_STRING ?
-                                    uLenOfEncodedMapOrArray : Nesting_GetCount(&(me->nesting));
+         // Number of bytes for a bstr or number of items a for map & array
+         const bool bIsBstr = uMajorType == CBOR_MAJOR_TYPE_BYTE_STRING;
+         const size_t uLength =  bIsBstr ? uLenOfEncodedMapOrArray
+                                         : Nesting_GetCount(&(me->nesting));
 
          // Actually insert
          InsertEncodedTypeAndNumber(me,
-                                    uMajorType,       // major type bstr, array or map
-                                    0,                // no minimum length for encoding
-                                    uLength,          // either len of bstr or num map / array items
+                                    uMajorType,       // bstr, array or map
+                                    0,                // no minimum length
+                                    uLength,          // either len of bstr or
+                                                      // num map / array items
                                     uInsertPosition); // position in out buffer
 
-         // Return pointer and length to the enclosed encoded CBOR. The intended
-         // use is for it to be hashed (e.g., SHA-256) in a COSE implementation.
-         // This must be used right away, as the pointer and length go invalid
-         // on any subsequent calls to this function because there might be calls to
-         // InsertEncodedTypeAndNumber() that slides data to the right.
+         /*
+          Return pointer and length to the enclosed encoded CBOR. The
+          intended use is for it to be hashed (e.g., SHA-256) in a
+          COSE implementation.  This must be used right away, as the
+          pointer and length go invalid on any subsequent calls to
+          this function because there might be calls to
+          InsertEncodedTypeAndNumber() that slides data to the right.
+          */
          if(pWrappedCBOR) {
             const UsefulBufC PartialResult = UsefulOutBuf_OutUBuf(&(me->OutBuf));
             *pWrappedCBOR = UsefulBuf_Tail(PartialResult, uInsertPosition);
@@ -638,10 +685,13 @@
    }
 }
 
+
 /*
- Public functions for closing arrays and maps. See header qcbor.h
+ Public functions for closing arrays and maps. See qcbor.h
  */
-void QCBOREncode_CloseMapOrArrayIndefiniteLength(QCBOREncodeContext *me, uint8_t uMajorType, UsefulBufC *pWrappedCBOR)
+void QCBOREncode_CloseMapOrArrayIndefiniteLength(QCBOREncodeContext *me,
+                                                 uint8_t uMajorType,
+                                                 UsefulBufC *pWrappedCBOR)
 {
    if(me->uError == QCBOR_SUCCESS) {
       if(!Nesting_IsInNest(&(me->nesting))) {
@@ -650,13 +700,20 @@
          me->uError = QCBOR_ERR_CLOSE_MISMATCH;
       } else {
          // insert the break marker (0xff for both arrays and maps)
-         InsertEncodedTypeAndNumber(me, CBOR_MAJOR_TYPE_SIMPLE, 0, CBOR_SIMPLE_BREAK, UsefulOutBuf_GetEndPosition(&(me->OutBuf)));
+         InsertEncodedTypeAndNumber(me,
+                                    CBOR_MAJOR_TYPE_SIMPLE,
+                                    0,
+                                    CBOR_SIMPLE_BREAK,
+                                    UsefulOutBuf_GetEndPosition(&(me->OutBuf)));
 
-         // Return pointer and length to the enclosed encoded CBOR. The intended
-         // use is for it to be hashed (e.g., SHA-256) in a COSE implementation.
-         // This must be used right away, as the pointer and length go invalid
-         // on any subsequent calls to this function because there might be calls to
-         // InsertEncodedTypeAndNumber() that slides data to the right.
+         /*
+          Return pointer and length to the enclosed encoded CBOR. The
+          intended use is for it to be hashed (e.g., SHA-256) in a
+          COSE implementation.  This must be used right away, as the
+          pointer and length go invalid on any subsequent calls to
+          this function because there might be calls to
+          InsertEncodedTypeAndNumber() that slides data to the right.
+          */
          if(pWrappedCBOR) {
             const UsefulBufC PartialResult = UsefulOutBuf_OutUBuf(&(me->OutBuf));
             *pWrappedCBOR = UsefulBuf_Tail(PartialResult, UsefulOutBuf_GetEndPosition(&(me->OutBuf)));
@@ -670,7 +727,7 @@
 
 
 /*
- Public functions to finish and get the encoded result. See header qcbor.h
+ Public functions to finish and get the encoded result. See qcbor.h
  */
 QCBORError QCBOREncode_Finish(QCBOREncodeContext *me, UsefulBufC *pEncodedCBOR)
 {
@@ -694,7 +751,7 @@
 
 
 /*
- Public functions to finish and get the encoded result. See header qcbor.h
+ Public functions to finish and get the encoded result. See qcbor.h
  */
 QCBORError QCBOREncode_FinishGetSize(QCBOREncodeContext *me, size_t *puEncodedLen)
 {
@@ -713,16 +770,6 @@
 
 
 /*
- Notes on the code
-
- CBOR Major Type     Public Function
- 0                   QCBOREncode_AddUInt64
- 0, 1                QCBOREncode_AddUInt64, QCBOREncode_AddInt64
- 2, 3                QCBOREncode_AddBuffer, Also QCBOREncode_OpenMapOrArray
- 4, 5                QCBOREncode_OpenMapOrArray
- 6                   QCBOREncode_AddTag
- 7                   QCBOREncode_AddDouble, QCBOREncode_AddType7
-
  Object code sizes on X86 with LLVM compiler and -Os (Dec 30, 2018)
 
  _QCBOREncode_Init   69