gs1syntaxdictionary-utils.h File Reference

Macros
#define	GS1_LINTER_RETURN_OK
	Return from a linter indicating that no problem was detected with the given data.
#define	GS1_LINTER_RETURN_ERROR(error, position, length)
	Return from a linter indicating that a problem was detected with the given data.
#define	GS1_LINTER_BITFIELD_LOOKUP(bit, field)
	Perform a lookup of a position in a bit field.
#define	GS1_LINTER_BINARY_SEARCH(needle, haystack)
	Perform a binary search for a search term in a sorted set of strings.

Purpose

This header provides utility macros used by the reference linter functions.

Macro Definition Documentation

GS1_LINTER_BINARY_SEARCH

#define GS1_LINTER_BINARY_SEARCH	(		needle,
			haystack
	)

Value:

do {                                                            \
        size_t s = 0;                                           \
        size_t e = sizeof(haystack) / sizeof(haystack[0]);      \
        while (s < e) {                                         \
                const size_t m = s + (e - s) / 2;               \
                const int cmp = strcmp(haystack[m], needle);    \
                if (cmp < 0)                                    \
                        s = m + 1;                              \
                else if (cmp > 0)                               \
                        e = m;                                  \
                else {                                          \
                        valid = 1;                              \
                        break;                                  \
                }                                               \
        }                                                       \
} while (0)

Perform a binary search for a search term in a sorted set of strings.

Parameters

[in]	needle	A search term string to be exactly matched.
[in]	haystack	A array of strings to be searched. The array must be otherwise the matching behaviour is undefined.

The macro's effect is to set the value of the variable valid to 1 if needle is found in haystack.

GS1_LINTER_BITFIELD_LOOKUP

#define GS1_LINTER_BITFIELD_LOOKUP	(		bit,
			field
	)

Value:

do {                                                                    \
        int w = CHAR_BIT * sizeof(field[0]);                            \
        assert((size_t)(bit/w) < sizeof(field) / sizeof(field[0]));     \
        if (field[bit/w] & (UINT64_C(1) << (w-1) >> (bit%w)))           \
                valid = 1;                                              \
} while (0)

Perform a lookup of a position in a bit field.

Parameters

[in]	bit	The bit position in the field to lookup. The position must be in the field otherwise the behaviour is undefined.
[in]	field	An array whose elements (of type with arbitrary size) when concatinated produce a single bit field whose positions are numbered from left to right (MSB of first element to LSB of last element).

The macro's effect is to set the value of the variable valid to 1 if the position numbered bit is set in the field.

GS1_LINTER_RETURN_ERROR

#define GS1_LINTER_RETURN_ERROR	(		error,
			position,
			length
	)

Value:

do {                                                            \
        if (err_pos) *err_pos = position;                       \
        if (err_len) *err_len = length;                         \
        return error;                                           \
} while (0)

Return from a linter indicating that a problem was detected with the given data.

Parameters

[in]	error	An error of type gs1_lint_err_t to return.
[in]	position	The starting position of the invalid data.
[in]	length	The length of the invalid data segment.

GS1_LINTER_RETURN_OK

#define GS1_LINTER_RETURN_OK

Value:

do {                                    \
        return GS1_LINTER_OK;           \
} while (0)

Return from a linter indicating that no problem was detected with the given data.

Note

For many linters this does not guarantee that the data is valid, only that it satisfies all of the checks performed by the linter.