comment and code tidying
diff --git a/inc/qcbor/qcbor_decode.h b/inc/qcbor/qcbor_decode.h
index c147a85..ecbcb44 100644
--- a/inc/qcbor/qcbor_decode.h
+++ b/inc/qcbor/qcbor_decode.h
@@ -1687,7 +1687,7 @@
void QCBORDecode_RewindMap(QCBORDecodeContext *pCtxt);
/*
- Indicate if decoding is in map mode more not.
+ Indicate if decoding is in bounded mord not.
*/
bool QCBORDecode_InBoundedMode(QCBORDecodeContext *pCtxt);
@@ -1718,7 +1718,7 @@
Get an item out of a map.
- Decoding must be in map mode for this to work.
+ Decoding must be in bounded for this to work.
@@ -1820,10 +1820,6 @@
The beginning of each map must be recorded so the scan can be done
through the whole map.
- A bit per level to indicate in map mode for that level so
- it is clear what GetNext at end does and what happens on MapExit
- and where to set the cursor.
-
diff --git a/inc/qcbor/qcbor_decode_map.h b/inc/qcbor/qcbor_decode_map.h
index ec6c43b..d4822dc 100644
--- a/inc/qcbor/qcbor_decode_map.h
+++ b/inc/qcbor/qcbor_decode_map.h
@@ -19,7 +19,7 @@
/* Next item must be map or this generates an error.
-This puts the decoder in map mode which narrows
+This puts the decoder in bounded mode which narrows
decoding to the map entered and enables use of
getting items by label.
@@ -28,9 +28,9 @@
Call QCBORDecode_ExitMap() to exit the current map
decoding level. When all map decoding layers are exited
- then map mode is fully exited.
+ then bounded mode is fully exited.
- While in map mode, GetNext works as usual on the
+ While in bounded mode, GetNext works as usual on the
map and the standard in-order traversal cursor
is maintained. Attempts to get items off the end of the
map will give error XXX (rather going to the next
@@ -43,7 +43,7 @@
Exiting leaves the cursor at the
data item following the last entry in the map.
- Entering and Exiting map mode consumes the whole
+ Entering and Exiting bounded mode consumes the whole
map and its contents as a GetNext after exiting
will return the item after the map. */
QCBORError QCBORDecode_EnterMap(QCBORDecodeContext *pCtx);
@@ -81,7 +81,7 @@
/*
Get an item out of a map.
- Decoding must be in map mode for this to work.
+ Decoding must be in bounded mode for this to work.
@@ -185,7 +185,7 @@
The beginning of each map must be recorded so the scan can be done
through the whole map.
- A bit per level to indicate in map mode for that level so
+ A bit per level to indicate in bounded mode for that level so
it is clear what GetNext at end does and what happens on MapExit
and where to set the cursor.
diff --git a/inc/qcbor/qcbor_private.h b/inc/qcbor/qcbor_private.h
index 0f754f5..422e527 100644
--- a/inc/qcbor/qcbor_private.h
+++ b/inc/qcbor/qcbor_private.h
@@ -122,8 +122,9 @@
PRIVATE DATA STRUCTURE
Holds the data for array and map nesting for decoding work. This
- structure and the DecodeNesting_xxx functions form an "object" that
- does the work for arrays and maps.
+ structure and the DecodeNesting_Xxx() functions in qcbor_decode.c
+ form an "object" that does the work for arrays and maps. All access
+ to this structure is through DecodeNesting_Xxx() functions.
64-bit machine size
128 = 16 * 8 for the two unions
@@ -131,8 +132,7 @@
16 = 16 bytes for two pointers
208 TOTAL
- 32-bit machine size is 8 bytes smaller because of the smaller pointers.
-
+ 32-bit machine size is 200 bytes
*/
typedef struct __QCBORDecodeNesting {
// PRIVATE DATA STRUCTURE
@@ -150,10 +150,11 @@
for 2).
Item tracking can either be for definite or indefinite length
- maps / arrays. For definite lengths, the total count and
- current position is tracked. For indefinite length, uTotalCount
- is QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH (UINT16_MAX) and
- there is no tracking in this data structure.
+ maps/arrays. For definite lengths, the total count and items
+ unconsumed is tracked. For indefinite length, uTotalCount is
+ QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH (UINT16_MAX) and
+ uCountCursor is UINT16_MAX if the map/array is not consumed and
+ zero if it is consumed in the pre-order traversal.
This also records whether a level is bounded or not. All
byte-count tracked levels (the top-level sequence and
@@ -163,7 +164,7 @@
by uStartOffset not being UINT32_MAX.
*/
/*
- If uLevelType can put in a separately indexed array, the union /
+ If uLevelType can put in a separately indexed array, the union/
struct will be 8 bytes rather than 9 and a lot of wasted
padding for alignment will be saved.
*/
@@ -181,7 +182,7 @@
uint32_t uPreviousEndOffset;
} bs; /* for top-level sequence and bstr wrapped CBOR */
} u;
- } pMapsAndArrays[QCBOR_MAX_ARRAY_NESTING1+1],
+ } pLevels[QCBOR_MAX_ARRAY_NESTING1+1],
*pCurrent,
*pCurrentBounded;
/*
diff --git a/src/qcbor_decode.c b/src/qcbor_decode.c
index 281f9e2..bf6e8ac 100644
--- a/src/qcbor_decode.c
+++ b/src/qcbor_decode.c
@@ -81,53 +81,14 @@
/*===========================================================================
- DecodeNesting -- Tracking array/map/sequence/bstr-wrapped nesting
-
- See qcbor/qcbor_private.h for definition of the object
- described here: QCBORDecodeNesting
+ DecodeNesting -- Tracking array/map/sequence/bstr-wrapped nesting
===========================================================================*/
/*
-The main mode of decoding is a pre-order travesal of the tree of leaves (numbers, strings...)
-formed by intermediate nodes (arrays and maps). The cursor for the traversal
- is the byte offset in the encoded input and a leaf counter for definite
- length maps and arrays. Indefinite length maps and arrays are handled
- by look ahead for the break.
-
- The view presented to the caller has tags, labels and the chunks of
- indefinite length strings aggregated into one decorated data item.
-
-The caller understands the nesting level in pre-order traversal by
- the fact that a data item that is a map or array is presented to
- the caller when it is first encountered in the pre-order traversal and that all data items are presented with its nesting level
- and the nesting level of the next item.
-
- The caller traverse maps and arrays in a special mode that often more convenient
- that tracking by nesting level. When an array or map is expected or encountered
- the EnterMap or EnteryArray can be called.
-
- When entering a map or array like this, the cursor points to the first
- item in the map or array. When exiting, it points to the item after
- the map or array, regardless of whether the items in the map or array were
- all traversed.
-
- When in a map or array, the cursor functions as normal, but traversal
- cannot go past the end of the map or array that was entered. If this
- is attempted the QCBOR_ERR_NO_MORE_ITEMS error is returned. To
- go past the end of the map or array ExitMap() or ExitArray() must
- be called. It can be called any time regardless of the position
- of the cursor.
-
- When a map is entered, a special function allows fetching data items
- by label. This call will traversal the whole map looking for the
- labeled item. The whole map is traversed so as to detect duplicates.
- This type of fetching items does not affect the normal traversal
- cursor.
+ See commecnts about and typedef of QCBORDecodeNesting in qcbor_private.h, the data structure
+ all these functions work on.
-When a data item is presented to the caller, the nesting level of the data
- item is presented along with the nesting level of the item that would be
- next consumed.
*/
@@ -135,7 +96,7 @@
inline static uint8_t
DecodeNesting_GetCurrentLevel(const QCBORDecodeNesting *pNesting)
{
- const ptrdiff_t nLevel = pNesting->pCurrent - &(pNesting->pMapsAndArrays[0]);
+ const ptrdiff_t nLevel = pNesting->pCurrent - &(pNesting->pLevels[0]);
/*
Limit in DecodeNesting_Descend against more than
QCBOR_MAX_ARRAY_NESTING gaurantees cast is safe
@@ -145,9 +106,9 @@
inline static uint8_t
-DecodeNesting_GetBoundedModeLevel(QCBORDecodeNesting *pNesting)
+DecodeNesting_GetBoundedModeLevel(const QCBORDecodeNesting *pNesting)
{
- const ptrdiff_t nLevel = pNesting->pCurrentBounded - &(pNesting->pMapsAndArrays[0]);
+ const ptrdiff_t nLevel = pNesting->pCurrentBounded - &(pNesting->pLevels[0]);
/*
Limit in DecodeNesting_Descend against more than
QCBOR_MAX_ARRAY_NESTING gaurantees cast is safe
@@ -157,7 +118,7 @@
static inline size_t
-DecodeNesting_GetMapOrArrayStart(QCBORDecodeNesting *pNesting)
+DecodeNesting_GetMapOrArrayStart(const QCBORDecodeNesting *pNesting)
{
return pNesting->pCurrentBounded->u.ma.uStartOffset;
}
@@ -166,7 +127,7 @@
inline static bool
DecodeNesting_IsCurrentAtTop(const QCBORDecodeNesting *pNesting)
{
- if(pNesting->pCurrent == &(pNesting->pMapsAndArrays[0])) {
+ if(pNesting->pCurrent == &(pNesting->pLevels[0])) {
return true;
} else {
return false;
@@ -175,26 +136,26 @@
inline static bool
-DecodeNesting_IsDefiniteLength(const QCBORDecodeNesting *pNesting)
+DecodeNesting_IsCurrentDefiniteLength(const QCBORDecodeNesting *pNesting)
{
if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
- /* Not a map or array */
+ // Not a map or array
return false;
}
if(pNesting->pCurrent->u.ma.uCountTotal == QCBOR_COUNT_INDICATES_INDEFINITE_LENGTH) {
- /* Is indefinite */
+ // Is indefinite
return false;
}
- /* All checks passed; is a definte length map or array */
+ // All checks passed; is a definte length map or array
return true;
}
inline static bool
-DecodeNesting_IsBstrWrapped(const QCBORDecodeNesting *pNesting)
+DecodeNesting_IsCurrentBstrWrapped(const QCBORDecodeNesting *pNesting)
{
if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
- /* is a byte string */
+ // is a byte string
return true;
}
return false;
@@ -213,7 +174,7 @@
}
-inline static void DecodeNesting_SetMapOrArrayBoundedMode(const QCBORDecodeNesting *pNesting, size_t uStart)
+inline static void DecodeNesting_SetMapOrArrayBoundedMode(QCBORDecodeNesting *pNesting, size_t uStart)
{
// Should be only called on maps and arrays
// TODO: check this cast, maybe give an error?
@@ -221,42 +182,41 @@
}
-inline static void DecodeNesting_ClearBoundedMode(const QCBORDecodeNesting *pNesting)
+inline static void DecodeNesting_ClearBoundedMode(QCBORDecodeNesting *pNesting)
{
pNesting->pCurrent->u.ma.uStartOffset = QCBOR_NON_BOUNDED_OFFSET;
}
inline static bool
-DecodeNesting_IsAtEndOfBoundedFarf(const QCBORDecodeNesting *pNesting)
+DecodeNesting_IsAtEndOfBoundedLevel(const QCBORDecodeNesting *pNesting)
{
if(pNesting->pCurrentBounded == NULL) {
- /* No bounded map or array or... set up. */
+ // No bounded map or array or... set up
return false;
}
if(pNesting->pCurrent->uLevelType == QCBOR_TYPE_BYTE_STRING) {
- /* Not a map or array */
+ // Not a map or array; end of those is by byte count */
return false;
}
if(!DecodeNesting_IsCurrentBounded(pNesting)) { // TODO: pCurrent vs pCurrentBounded
- /* Not in bounded mode. */
+ // Not at a bounded level
return false;
}
-
// Works for both definite and indefinite length maps/arrays
if(pNesting->pCurrentBounded->u.ma.uCountCursor != 0) {
- /* Count is not zero, still unconsumed items. */
+ // Count is not zero, still unconsumed item
return false;
}
-
- /* All checks passed, got to the end of a definite length map or array */
+ // All checks passed, got to the end of a map/array
return true;
}
+
inline static bool
-DecodeNesting_IsEndOfDefiniteLengthMapOrArray(QCBORDecodeNesting *pNesting)
+DecodeNesting_IsEndOfDefiniteLengthMapOrArray(const QCBORDecodeNesting *pNesting)
{
- /* Must only be called on map / array; TODO: add checks? */
+ // Must only be called on map / array
if(pNesting->pCurrent->u.ma.uCountCursor == 0) {
return true;
} else {
@@ -294,12 +254,20 @@
inline static void
DecodeNesting_DecrementDefiniteLengthMapOrArrayCount(QCBORDecodeNesting *pNesting)
{
- /* Only call on array / map; TODO: add check?*/
+ // Only call on a defnite length array / map
pNesting->pCurrent->u.ma.uCountCursor--;
}
inline static void
+DecodeNesting_ReverseDecrement(QCBORDecodeNesting *pNesting)
+{
+ // Only call on a defnite length array / map
+ pNesting->pCurrent->u.ma.uCountCursor++;
+}
+
+
+inline static void
DecodeNesting_Ascend(QCBORDecodeNesting *pNesting)
{
pNesting->pCurrent--;
@@ -310,7 +278,7 @@
DecodeNesting_Decsend(QCBORDecodeNesting *pNesting, uint8_t uType)
{
// Error out if nesting is too deep
- if(pNesting->pCurrent >= &(pNesting->pMapsAndArrays[QCBOR_MAX_ARRAY_NESTING])) {
+ if(pNesting->pCurrent >= &(pNesting->pLevels[QCBOR_MAX_ARRAY_NESTING])) {
return QCBOR_ERR_ARRAY_NESTING_TOO_DEEP;
}
@@ -326,7 +294,12 @@
inline static void
DecodeNesting_EnterBoundedMode(QCBORDecodeNesting *pNesting, size_t uOffset)
{
- /* Have descended into this before this is called. The job here is just to mark it in bounded mode */
+ /*
+ Should only be called on map/array.
+
+ Have descended into this before this is called. The job here is
+ just to mark it in bounded mode.
+ */
pNesting->pCurrentBounded = pNesting->pCurrent;
DecodeNesting_SetMapOrArrayBoundedMode(pNesting, uOffset);
}
@@ -379,7 +352,7 @@
static inline void
DecodeNesting_LevelUpBounded(QCBORDecodeNesting *pNesting)
{
- while(pNesting->pCurrentBounded != &(pNesting->pMapsAndArrays[0])) {
+ while(pNesting->pCurrentBounded != &(pNesting->pLevels[0])) {
pNesting->pCurrentBounded--;
if(DecodeNesting_IsCurrentBounded(pNesting)) {
break;
@@ -387,6 +360,12 @@
}
}
+static inline void
+DecodeNesting_SetCurrentToBoundedLevel(QCBORDecodeNesting *pNesting)
+{
+ pNesting->pCurrent = pNesting->pCurrentBounded;
+}
+
inline static QCBORError
DecodeNesting_DescendIntoBstrWrapped(QCBORDecodeNesting *pNesting,
@@ -414,7 +393,7 @@
static inline void
-DecodeNesting_ZeroDefiniteLengthCount(QCBORDecodeNesting *pNesting)
+DecodeNesting_ZeroMapOrArrayCount(QCBORDecodeNesting *pNesting)
{
pNesting->pCurrent->u.ma.uCountCursor = 0;
}
@@ -424,8 +403,8 @@
DecodeNesting_Init(QCBORDecodeNesting *pNesting)
{
/* Assumes that *pNesting has been zero'd before this call. */
- pNesting->pMapsAndArrays[0].uLevelType = QCBOR_TYPE_BYTE_STRING;
- pNesting->pCurrent = &(pNesting->pMapsAndArrays[0]);
+ pNesting->pLevels[0].uLevelType = QCBOR_TYPE_BYTE_STRING;
+ pNesting->pCurrent = &(pNesting->pLevels[0]);
}
@@ -434,28 +413,26 @@
{
*pSave = *pNesting;
pNesting->pCurrent = pNesting->pCurrentBounded;
-
- //if(!DecodeNesting_IsIndefiniteLength(pNesting)) {
- pNesting->pCurrent->u.ma.uCountCursor = pNesting->pCurrent->u.ma.uCountTotal;
- //}
+ pNesting->pCurrent->u.ma.uCountCursor = pNesting->pCurrent->u.ma.uCountTotal;
}
+
static inline void
-DecodeNesting_RestoreFromMapSearch(QCBORDecodeNesting *pNesting, QCBORDecodeNesting *pSave)
+DecodeNesting_RestoreFromMapSearch(QCBORDecodeNesting *pNesting, const QCBORDecodeNesting *pSave)
{
*pNesting = *pSave;
}
static inline uint32_t
-DecodeNesting_GetEndOfBstr(QCBORDecodeNesting *pMe)
+DecodeNesting_GetEndOfBstr(const QCBORDecodeNesting *pMe)
{
return pMe->pCurrentBounded->u.bs.uEndOfBstr;
}
static inline uint32_t
-DecodeNesting_GetPreviousBoundedEnd(QCBORDecodeNesting *pMe)
+DecodeNesting_GetPreviousBoundedEnd(const QCBORDecodeNesting *pMe)
{
return pMe->pCurrentBounded->u.bs.uPreviousEndOffset;
}
@@ -484,6 +461,7 @@
return buf;
}
+
void DecodeNesting_Print(QCBORDecodeNesting *pNesting, UsefulInputBuf *pBuf, const char *szName)
{
printf("---%s--%d/%d--\narrow is current bounded level\n",
@@ -493,50 +471,30 @@
printf("Level Type Count Offsets \n");
for(int i = 0; i < QCBOR_MAX_ARRAY_NESTING; i++) {
- if(&(pNesting->pMapsAndArrays[i]) > pNesting->pCurrent) {
+ if(&(pNesting->pLevels[i]) > pNesting->pCurrent) {
break;
}
printf("%2s %2d %s ",
- pNesting->pCurrentBounded == &(pNesting->pMapsAndArrays[i]) ? "->": " ",
+ pNesting->pCurrentBounded == &(pNesting->pLevels[i]) ? "->": " ",
i,
- TypeStr(pNesting->pMapsAndArrays[i].uLevelType));
+ TypeStr(pNesting->pLevels[i].uLevelType));
- if(pNesting->pMapsAndArrays[i].uLevelType == QCBOR_TYPE_BYTE_STRING) {
+ if(pNesting->pLevels[i].uLevelType == QCBOR_TYPE_BYTE_STRING) {
printf(" %5d %5d",
- pNesting->pMapsAndArrays[i].u.bs.uEndOfBstr,
- pNesting->pMapsAndArrays[i].u.bs.uPreviousEndOffset);
+ pNesting->pLevels[i].u.bs.uEndOfBstr,
+ pNesting->pLevels[i].u.bs.uPreviousEndOffset);
} else {
printf("%10.10s ",
- CountString(pNesting->pMapsAndArrays[i].u.ma.uCountCursor,
- pNesting->pMapsAndArrays[i].u.ma.uCountTotal));
- if(pNesting->pMapsAndArrays[i].u.ma.uStartOffset != UINT32_MAX) {
- printf("Bounded start: %u",pNesting->pMapsAndArrays[i].u.ma.uStartOffset);
+ CountString(pNesting->pLevels[i].u.ma.uCountCursor,
+ pNesting->pLevels[i].u.ma.uCountTotal));
+ if(pNesting->pLevels[i].u.ma.uStartOffset != UINT32_MAX) {
+ printf("Bounded start: %u",pNesting->pLevels[i].u.ma.uStartOffset);
}
}
printf("\n");
- /*
- TYPE
- count/total
- start offset/unbound
- */
-
-/* printf("%2s %2d %5d %s %6u %5d %d %5d\n",
- pNesting->pCurrentBounded == &(pNesting->pMapsAndArrays[i]) ? "->": " ",
- i,
- pNesting->pMapsAndArrays[i].u.ma.uCountCursor,
- pNesting->pMapsAndArrays[i].uLevelType == QCBOR_TYPE_MAP ? "map " :
- (pNesting->pMapsAndArrays[i].uLevelType == QCBOR_TYPE_ARRAY ? "array" :
- (pNesting->pMapsAndArrays[i].uLevelType == QCBOR_TYPE_BYTE_STRING ? "bstr " :
- (pNesting->pMapsAndArrays[i].uLevelType == QCBOR_TYPE_NONE ? "none " : "?????"))),
- pNesting->pMapsAndArrays[i].u.ma.uStartOffset,
- pNesting->pMapsAndArrays[i].u.ma.uCountTotal,
- 0, // TODO: fix this
- pNesting->pMapsAndArrays[i].u.bs.uPreviousEndOffset
- );
-*/
}
printf("\n");
}
@@ -625,10 +583,12 @@
/*
Public function, see header file
*/
-void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *me,
+void QCBORDecode_SetCallerConfiguredTagList(QCBORDecodeContext *pMe,
const QCBORTagListIn *pTagList)
{
// This does nothing now. It is retained for backwards compatibility
+ (void)pMe;
+ (void)pTagList;
}
@@ -1324,7 +1284,7 @@
/* This loops ascending nesting levels as long as there is ascending to do */
while(!DecodeNesting_IsCurrentAtTop(&(pMe->nesting))) {
- if(DecodeNesting_IsDefiniteLength(&(pMe->nesting))) {
+ if(DecodeNesting_IsCurrentDefiniteLength(&(pMe->nesting))) {
/* Decrement count for definite length maps / arrays */
DecodeNesting_DecrementDefiniteLengthMapOrArrayCount(&(pMe->nesting));
if(!DecodeNesting_IsEndOfDefiniteLengthMapOrArray(&(pMe->nesting))) {
@@ -1346,7 +1306,7 @@
break;
}
- if(DecodeNesting_IsBstrWrapped(&(pMe->nesting))) {
+ if(DecodeNesting_IsCurrentBstrWrapped(&(pMe->nesting))) {
/*
Break occurred inside a bstr-wrapped CBOR or
in the top level sequence. This is always an
@@ -1366,7 +1326,7 @@
/* Set the count to zero for definite length arrays to indicate cursor is at end of bounded map / array */
if(bMarkEnd) {
// Used for definite and indefinite to signal end
- DecodeNesting_ZeroDefiniteLengthCount(&(pMe->nesting));
+ DecodeNesting_ZeroMapOrArrayCount(&(pMe->nesting));
}
break;
@@ -1422,7 +1382,7 @@
array. The check for the end of an indefinite length array is
later.
*/
- if(DecodeNesting_IsAtEndOfBoundedFarf(&(me->nesting))) {
+ if(DecodeNesting_IsAtEndOfBoundedLevel(&(me->nesting))) {
uReturn = QCBOR_ERR_NO_MORE_ITEMS;
goto Done;
}
@@ -1498,7 +1458,7 @@
reconstruct the tree with just the information returned in
a QCBORItem.
*/
- if(DecodeNesting_IsAtEndOfBoundedFarf(&(me->nesting))) {
+ if(DecodeNesting_IsAtEndOfBoundedLevel(&(me->nesting))) {
/* At end of a bounded map/array; uNextNestLevel 0 to indicate this */
pDecodedItem->uNextNestLevel = 0;
} else {
@@ -2678,7 +2638,7 @@
/* Need to get the current pre-order nesting level and cursor to be
at the map/array about to be entered.
- Also need to current map nesting level and start cursor to
+ Also need the current map nesting level and start cursor to
be at the right place.
The UsefulInBuf offset could be anywhere, so no assumption is
@@ -2686,12 +2646,13 @@
No assumption is made about the pre-order nesting level either.
- However the map mode nesting level is assumed to be one above
+ However the bounded mode nesting level is assumed to be one above
the map level that is being entered.
*/
/* Seek to the data item that is the map or array */
UsefulInputBuf_Seek(&(pMe->InBuf), uOffset);
- pMe->nesting.pCurrent = pMe->nesting.pCurrentBounded; // TODO: part of DecodeNesting
+
+ DecodeNesting_SetCurrentToBoundedLevel(&(pMe->nesting));
QCBORDecode_EnterBoundedMode(pMe, pSearch->uDataType);
}
@@ -2757,16 +2718,16 @@
// Semi-private function
-/* Next item must be map or this generates an error */
void QCBORDecode_EnterBoundedMode(QCBORDecodeContext *pMe, uint8_t uType)
{
+ /* Must only be called on maps and arrays. */
if(pMe->uLastError != QCBOR_SUCCESS) {
// Already in error state; do nothing.
return;
}
/* Get the data item that is the map that is being searched */
- QCBORItem Item;
+ QCBORItem Item;
pMe->uLastError = (uint8_t)QCBORDecode_GetNext(pMe, &Item);
if(pMe->uLastError != QCBOR_SUCCESS) {
return;
@@ -2912,12 +2873,11 @@
goto Done;
}
- if(DecodeNesting_IsDefiniteLength(&(pMe->nesting))) {
+ if(DecodeNesting_IsCurrentDefiniteLength(&(pMe->nesting))) {
/* Reverse the decrement done by GetNext() for the bstr as
so the increment in NestLevelAscender called by ExitBoundedLevel()
will work right. */
- // TODO: method for this
- pMe->nesting.pCurrent->u.ma.uCountCursor++;
+ DecodeNesting_ReverseDecrement(&(pMe->nesting));
}
if(pBstr) {
@@ -2934,7 +2894,6 @@
const size_t uEndOfBstr = UsefulInputBuf_Tell(&(pMe->InBuf));
-
UsefulInputBuf_Seek(&(pMe->InBuf), uEndOfBstr - pItem->val.string.len);
UsefulInputBuf_SetBufferLen(&(pMe->InBuf), uEndOfBstr);
@@ -4507,3 +4466,48 @@
}
}
#endif /* ndef QCBOR_CONFIG_DISABLE_EXP_AND_MANTISSA */
+
+/*
+
+ TODO: do something with this text
+ The main mode of decoding is a pre-order travesal of the tree of leaves (numbers, strings...)
+ formed by intermediate nodes (arrays and maps). The cursor for the traversal
+ is the byte offset in the encoded input and a leaf counter for definite
+ length maps and arrays. Indefinite length maps and arrays are handled
+ by look ahead for the break.
+
+ The view presented to the caller has tags, labels and the chunks of
+ indefinite length strings aggregated into one decorated data item.
+
+ The caller understands the nesting level in pre-order traversal by
+ the fact that a data item that is a map or array is presented to
+ the caller when it is first encountered in the pre-order traversal and that all data items are presented with its nesting level
+ and the nesting level of the next item.
+
+ The caller traverse maps and arrays in a special mode that often more convenient
+ that tracking by nesting level. When an array or map is expected or encountered
+ the EnterMap or EnteryArray can be called.
+
+ When entering a map or array like this, the cursor points to the first
+ item in the map or array. When exiting, it points to the item after
+ the map or array, regardless of whether the items in the map or array were
+ all traversed.
+
+ When in a map or array, the cursor functions as normal, but traversal
+ cannot go past the end of the map or array that was entered. If this
+ is attempted the QCBOR_ERR_NO_MORE_ITEMS error is returned. To
+ go past the end of the map or array ExitMap() or ExitArray() must
+ be called. It can be called any time regardless of the position
+ of the cursor.
+
+ When a map is entered, a special function allows fetching data items
+ by label. This call will traversal the whole map looking for the
+ labeled item. The whole map is traversed so as to detect duplicates.
+ This type of fetching items does not affect the normal traversal
+ cursor.
+
+
+ When a data item is presented to the caller, the nesting level of the data
+ item is presented along with the nesting level of the item that would be
+ next consumed.
+ */