Vstr documentation -- constants

Index of sections

• Compile switch constants
  • VSTR_COMPILE_ATTRIBUTES
  • VSTR_COMPILE_INCLUDE
  • VSTR_COMPILE_INLINE
  • VSTR_COMPILE_MACRO_FUNCTIONS
  • VSTR_COMPILE_TYPEDEF
• Global constants
  • VSTR_MAX_NODE_ALL
  • VSTR_MAX_NODE_BUF
• Constants passed to vstr_make_spare_nodes() and vstr_free_spare_nodes()
  • VSTR_TYPE_NODE_BUF
  • VSTR_TYPE_NODE_NON
  • VSTR_TYPE_NODE_PTR
  • VSTR_TYPE_NODE_REF
• Constants passed to vstr_add_vstr() and vstr_sub_vstr()
  • VSTR_TYPE_ADD_DEF
  • VSTR_TYPE_SUB_DEF
  • VSTR_TYPE_ADD_BUF_PTR
  • VSTR_TYPE_SUB_BUF_PTR
  • VSTR_TYPE_ADD_BUF_REF
  • VSTR_TYPE_SUB_BUF_REF
  • VSTR_TYPE_ADD_ALL_REF
  • VSTR_TYPE_SUB_ALL_REF
  • VSTR_TYPE_ADD_ALL_BUF
  • VSTR_TYPE_SUB_ALL_BUF
• Constants passed to vstr_fmt_add()
  • VSTR_TYPE_FMT_END
  • VSTR_TYPE_FMT_INT
  • VSTR_TYPE_FMT_UINT
  • VSTR_TYPE_FMT_LONG
  • VSTR_TYPE_FMT_ULONG
  • VSTR_TYPE_FMT_LONG_LONG
  • VSTR_TYPE_FMT_ULONG_LONG
  • VSTR_TYPE_FMT_SSIZE_T
  • VSTR_TYPE_FMT_SIZE_T
  • VSTR_TYPE_FMT_PTRDIFF_T
  • VSTR_TYPE_FMT_INTMAX_T
  • VSTR_TYPE_FMT_UINTMAX_T
  • VSTR_TYPE_FMT_DOUBLE
  • VSTR_TYPE_FMT_DOUBLE_LONG
  • VSTR_TYPE_FMT_PTR_VOID
  • VSTR_TYPE_FMT_PTR_CHAR
  • VSTR_TYPE_FMT_PTR_WCHAR_T
  • VSTR_TYPE_FMT_ERRNO
• Constants passed to vstr_sc_fmt_cb_beg()
  • VSTR_FLAG_SC_FMT_CB_BEG_DEF
  • VSTR_FLAG_SC_FMT_CB_BEG_OBJ_STR
  • VSTR_FLAG_SC_FMT_CB_BEG_OBJ_ATOM
  • VSTR_FLAG_SC_FMT_CB_BEG_OBJ_NUM
  • VSTR_FLAG_SC_FMT_CB_BEG_OBJ_NEG
• Constants passed to vstr_conv_unprintable_del() and vstr_conv_unprintable_chr()
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_NONE
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_NUL
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_BEL
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_BS
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_HT
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_LF
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_VT
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_FF
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_CR
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_SP
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_COMMA
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_DOT
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW__
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_ESC
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_DEL
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_HSP
  • VSTR_FLAG_CONV_UNPRINTABLE_ALLOW_HIGH
  • VSTR_FLAG_CONV_UNPRINTABLE_DEF
• Constants passed to vstr_parse_[u](short|int|long|intmax)()
  • VSTR_TYPE_PARSE_NUM_ERR_NONE
  • VSTR_TYPE_PARSE_NUM_ERR_ONLY_S
  • VSTR_TYPE_PARSE_NUM_ERR_ONLY_SPM
  • VSTR_TYPE_PARSE_NUM_ERR_ONLY_SPMX
  • VSTR_TYPE_PARSE_NUM_ERR_OOB
  • VSTR_TYPE_PARSE_NUM_ERR_OVERFLOW
  • VSTR_TYPE_PARSE_NUM_ERR_NEGATIVE
  • VSTR_TYPE_PARSE_NUM_ERR_BEG_ZERO
  • VSTR_FLAG_PARSE_NUM_DEF
  • VSTR_FLAG_PARSE_NUM_LOCAL
  • VSTR_FLAG_PARSE_NUM_SEP
  • VSTR_FLAG_PARSE_NUM_OVERFLOW
  • VSTR_FLAG_PARSE_NUM_SPACE
  • VSTR_FLAG_PARSE_NUM_NO_BEG_ZERO
  • VSTR_FLAG_PARSE_NUM_NO_BEG_PM
• Constants passed to vstr_parse_ipv4()
  • VSTR_TYPE_PARSE_IPV4_ERR_NONE
  • VSTR_TYPE_PARSE_IPV4_ERR_IPV4_OOB
  • VSTR_TYPE_PARSE_IPV4_ERR_IPV4_FULL
  • VSTR_TYPE_PARSE_IPV4_ERR_ONLY
  • VSTR_TYPE_PARSE_IPV4_ERR_CIDR_OOB
  • VSTR_TYPE_PARSE_IPV4_ERR_CIDR_FULL
  • VSTR_TYPE_PARSE_IPV4_ERR_NETMASK_OOB
  • VSTR_TYPE_PARSE_IPV4_ERR_NETMASK_FULL
  • VSTR_FLAG_PARSE_IPV4_DEF
  • VSTR_FLAG_PARSE_IPV4_LOCAL
  • VSTR_FLAG_PARSE_IPV4_ZEROS
  • VSTR_FLAG_PARSE_IPV4_FULL
  • VSTR_FLAG_PARSE_IPV4_CIDR
  • VSTR_FLAG_PARSE_IPV4_CIDR_FULL
  • VSTR_FLAG_PARSE_IPV4_NETMASK
  • VSTR_FLAG_PARSE_IPV4_NETMASK_FULL
  • VSTR_FLAG_PARSE_IPV4_ONLY
• Constants passed to vstr_parse_ipv6()
  • VSTR_TYPE_PARSE_IPV6_ERR_NONE
  • VSTR_TYPE_PARSE_IPV6_ERR_IPV6_OOB
  • VSTR_TYPE_PARSE_IPV6_ERR_IPV6_FULL
  • VSTR_TYPE_PARSE_IPV6_ERR_ONLY
  • VSTR_TYPE_PARSE_IPV6_ERR_CIDR_OOB
  • VSTR_TYPE_PARSE_IPV6_ERR_CIDR_FULL
  • VSTR_TYPE_PARSE_IPV6_ERR_IPV6_NULL
  • VSTR_FLAG_PARSE_IPV6_DEF
  • VSTR_FLAG_PARSE_IPV6_LOCAL
  • VSTR_FLAG_PARSE_IPV6_CIDR
  • VSTR_FLAG_PARSE_IPV6_CIDR_FULL
  • VSTR_FLAG_PARSE_IPV6_ONLY
• Constants used with the custom output formatter for ipv6 addresses
  • VSTR_TYPE_SC_FMT_CB_IPV6_ALIGNED
  • VSTR_TYPE_SC_FMT_CB_IPV6_COMPACT
  • VSTR_TYPE_SC_FMT_CB_IPV6_STD
  • VSTR_TYPE_SC_FMT_CB_IPV6_IPV4_ALIGNED
  • VSTR_TYPE_SC_FMT_CB_IPV6_IPV4_COMPACT
  • VSTR_TYPE_SC_FMT_CB_IPV6_IPV4_STD
• Constants passed to vstr_split_buf(), vstr_split_cstr_buf(), VSTR_SPLIT_CSTR_BUF(), vstr_split_chrs(), vstr_split_cstr_chrs() and VSTR_SPLIT_CSTR_CHRS()
  • VSTR_FLAG_SPLIT_DEF
  • VSTR_FLAG_SPLIT_BEG_NULL
  • VSTR_FLAG_SPLIT_MID_NULL
  • VSTR_FLAG_SPLIT_END_NULL
  • VSTR_FLAG_SPLIT_POST_NULL
  • VSTR_FLAG_SPLIT_NO_RET
  • VSTR_FLAG_SPLIT_REMAIN
• Constants passed to vstr_sects_foreach()
  • VSTR_FLAG_SECTS_FOREACH_DEF
  • VSTR_FLAG_SECTS_FOREACH_BACKWARD
  • VSTR_FLAG_SECTS_FOREACH_ALLOW_NULL
  • VSTR_TYPE_SECTS_FOREACH_DEF
  • VSTR_TYPE_SECTS_FOREACH_DEL
  • VSTR_TYPE_SECTS_FOREACH_RET
• Constants used with the callback from vstr_cache_add_cb()
  • VSTR_TYPE_CACHE_ADD
  • VSTR_TYPE_CACHE_DEL
  • VSTR_TYPE_CACHE_SUB
  • VSTR_TYPE_CACHE_FREE
• Constants passed to vstr_sc_mmap_fd() and vstr_sc_mmap_file()
  • VSTR_TYPE_SC_MMAP_FD_ERR_NONE
  • VSTR_TYPE_SC_MMAP_FILE_ERR_NONE
  • VSTR_TYPE_SC_MMAP_FILE_ERR_OPEN_ERRNO
  • VSTR_TYPE_SC_MMAP_FD_ERR_FSTAT_ERRNO
  • VSTR_TYPE_SC_MMAP_FILE_ERR_FSTAT_ERRNO
  • VSTR_TYPE_SC_MMAP_FD_ERR_MMAP_ERRNO
  • VSTR_TYPE_SC_MMAP_FILE_ERR_MMAP_ERRNO
  • VSTR_TYPE_SC_MMAP_FILE_ERR_CLOSE_ERRNO
  • VSTR_TYPE_SC_MMAP_FD_ERR_MEM
  • VSTR_TYPE_SC_MMAP_FILE_ERR_MEM
  • VSTR_TYPE_SC_MMAP_FD_ERR_TOO_LARGE
  • VSTR_TYPE_SC_MMAP_FILE_ERR_TOO_LARGE
• Constants passed to vstr_sc_read_iov_fd(), vstr_sc_read_len_fd(), vstr_sc_read_iov_file() and vstr_sc_read_len_file()
  • VSTR_TYPE_SC_READ_FD_ERR_NONE
  • VSTR_TYPE_SC_READ_FILE_ERR_NONE
  • VSTR_TYPE_SC_READ_FILE_ERR_OPEN_ERRNO
  • VSTR_TYPE_SC_READ_FD_ERR_FSTAT_ERRNO
  • VSTR_TYPE_SC_READ_FILE_ERR_FSTAT_ERRNO
  • VSTR_TYPE_SC_READ_FILE_ERR_SEEK_ERRNO
  • VSTR_TYPE_SC_READ_FD_ERR_READ_ERRNO
  • VSTR_TYPE_SC_READ_FILE_ERR_READ_ERRNO
  • VSTR_TYPE_SC_READ_FILE_ERR_CLOSE_ERRNO
  • VSTR_TYPE_SC_READ_FD_ERR_EOF
  • VSTR_TYPE_SC_READ_FILE_ERR_EOF
  • VSTR_TYPE_SC_READ_FD_ERR_MEM
  • VSTR_TYPE_SC_READ_FILE_ERR_MEM
  • VSTR_TYPE_SC_READ_FD_ERR_TOO_LARGE
  • VSTR_TYPE_SC_READ_FILE_ERR_TOO_LARGE
• Constants passed to vstr_sc_write_fd() and vstr_sc_write_file()
  • VSTR_TYPE_SC_WRITE_FD_ERR_NONE
  • VSTR_TYPE_SC_WRITE_FILE_ERR_NONE
  • VSTR_TYPE_SC_WRITE_FILE_ERR_SEEK_ERRNO
  • VSTR_TYPE_SC_WRITE_FILE_ERR_OPEN_ERRNO
  • VSTR_TYPE_SC_WRITE_FD_ERR_WRITE_ERRNO
  • VSTR_TYPE_SC_WRITE_FILE_ERR_WRITE_ERRNO
  • VSTR_TYPE_SC_WRITE_FILE_ERR_CLOSE_ERRNO
  • VSTR_TYPE_SC_WRITE_FD_ERR_MEM
  • VSTR_TYPE_SC_WRITE_FILE_ERR_MEM
• Constants passed to vstr_cntl_base()
  • VSTR_CNTL_BASE_GET_CONF
  • VSTR_CNTL_BASE_SET_CONF
  • VSTR_CNTL_BASE_GET_FLAG_HAVE_CACHE
• Constants passed to vstr_cntl_conf()
  • VSTR_CNTL_CONF_GET_NUM_BUF_SZ
  • VSTR_CNTL_CONF_SET_NUM_BUF_SZ
  • VSTR_CNTL_CONF_GET_NUM_IOV_MIN_ALLOC
  • VSTR_CNTL_CONF_SET_NUM_IOV_MIN_ALLOC
  • VSTR_CNTL_CONF_GET_NUM_IOV_MIN_OFFSET
  • VSTR_CNTL_CONF_SET_NUM_IOV_MIN_OFFSET
  • VSTR_CNTL_CONF_GET_NUM_REF
  • VSTR_CNTL_CONF_SET_LOC_CSTR_AUTO_NAME_NUMERIC
  • VSTR_CNTL_CONF_GET_LOC_CSTR_NAME_NUMERIC
  • VSTR_CNTL_CONF_SET_LOC_CSTR_NAME_NUMERIC
  • VSTR_CNTL_CONF_GET_LOC_CSTR_DEC_POINT
  • VSTR_CNTL_CONF_SET_LOC_CSTR_DEC_POINT
  • VSTR_CNTL_CONF_GET_LOC_CSTR_THOU_SEP
  • VSTR_CNTL_CONF_SET_LOC_CSTR_THOU_SEP
  • VSTR_CNTL_CONF_GET_LOC_CSTR_THOU_GRP
  • VSTR_CNTL_CONF_SET_LOC_CSTR_THOU_GRP
  • VSTR_CNTL_CONF_GET_FLAG_IOV_UPDATE
  • VSTR_CNTL_CONF_SET_FLAG_IOV_UPDATE
  • VSTR_CNTL_CONF_GET_FLAG_DEL_SPLIT
  • VSTR_CNTL_CONF_SET_FLAG_DEL_SPLIT
  • VSTR_CNTL_CONF_GET_FLAG_ALLOC_CACHE
  • VSTR_CNTL_CONF_SET_FLAG_ALLOC_CACHE
  • VSTR_CNTL_CONF_GET_FMT_CHAR_ESC
  • VSTR_CNTL_CONF_SET_FMT_CHAR_ESC
  • VSTR_CNTL_CONF_GET_NUM_SPARE_BUF
  • VSTR_CNTL_CONF_GET_NUM_SPARE_NON
  • VSTR_CNTL_CONF_GET_NUM_SPARE_PTR
  • VSTR_CNTL_CONF_GET_NUM_SPARE_REF
  • VSTR_CNTL_CONF_SET_NUM_SPARE_BUF
  • VSTR_CNTL_CONF_SET_NUM_SPARE_NON
  • VSTR_CNTL_CONF_SET_NUM_SPARE_PTR
  • VSTR_CNTL_CONF_SET_NUM_SPARE_REF
  • VSTR_CNTL_CONF_GET_FLAG_ATOMIC_OPS
  • VSTR_CNTL_CONF_SET_FLAG_ATOMIC_OPS
  • VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_BUF
  • VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_NON
  • VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_PTR
  • VSTR_CNTL_CONF_SET_NUM_RANGE_SPARE_REF
• Constants passed to vstr_cntl_opt()
  • VSTR_CNTL_OPT_GET_CONF
  • VSTR_CNTL_OPT_SET_CONF

This switch controls whether gcc type __attribute__() statements are used in the public headers headers for the library. If the value is 1 then if they are supported by the compiler that built the library they will be used, if the value is 0 they won't be used at all.

This switch controls whether including <vstr.h> will include all the system headers needed for the exported interfaces. If the value is 1 then if they are included, if the value is 0 they won't be included.

This switch controls whether inline functions will be used in the public headers for the library. If the value is 1 then if they are supported by the compiler that built the library they will be used, if the value is 0 they won't be used.

This switch controls whether macro functions will be used in the public headers for the library. If the value is 1 then they will be used, if the value is 0 they won't be used.

This only includes the macro functions which also have real function replacements. For example VSTR_ADD_CSTR_BUF() won't be defined because there is a vstr_add_cstr_buf() function, but VSTR_FMT_CB_ARG_PTR() will always be defined.

This switch controls whether typedef will be used for the structs in the public headers for the library. If the value is 1 then they will be used, if the value is 0 they won't be used at all (and your code will have to use struct tags instead -- note all libraries using vstr should compile with this option set).

This is the largest size a node can be, if you pass values greater than this to vstr_add_ptr() etc. then multiple nodes will be allocated.

This is the largest size a node _BUF type can be, if you pass values greater than this to vstr_add_buf() etc. then multiple nodes will be allocated.

Constants passed to vstr_make_spare_nodes() and vstr_free_spare_nodes()

This type when passed to vstr_make_space_nodes() specifies nodes of type _BUF, which are the only nodes that can be "written" to. These nodes are added into a Vstr string by the vstr_add_buf() function and the vstr_add_iovec_buf_*() functions.

A call to vstr_sub_buf() with a Vstr string consisting of _BUF nodes means that data will be substituted inplace.

This type when passed to vstr_make_space_nodes() specifies nodes of type _NON, which are nodes that contain "nothing". These nodes can be used as placeholders for data, and are added into a Vstr string by the vstr_add_non() function.

This type when passed to vstr_make_space_nodes() specifies nodes of type _PTR, which are nodes that contain a memory pointer to an area of memory.

This type when passed to vstr_make_space_nodes() specifies nodes of type _REF, which are nodes that contain a Vstr memory reference.

Constants passed to vstr_add_vstr() and vstr_sub_vstr()

This type when passed to either vstr_sub_vstr() or vstr_add_vstr() specifies that all types of nodes are added as their respective type.

This type when passed to either vstr_sub_vstr() or vstr_add_vstr() specifies that all nodes of type _BUF are added as type _PTR.

If you add/del/sub data in the original Vstr string then because the added data is only pointers to the old data, life may become interesting for you.

This type when passed to either vstr_sub_vstr() or vstr_add_vstr() specifies that all nodes of type _BUF are converted to type _REF before being added.

This means that if you do a substitution on the original Vstr string it will now be less efficient, as the _REF nodes cannot have data substituted in place.

The _BUF nodes will not go back to the pool in the Vstr configuration as happens if you deleted them.

This type when passed to either vstr_sub_vstr() or vstr_add_vstr() specifies that the data should be taken as though vstr_export_ref() was called on the original Vstr string.

This type when passed to either vstr_sub_vstr() or vstr_add_vstr() specifies that the data should all be added via. vstr_add_buf().

Constants passed to vstr_fmt_add()

This flag means that there are no more arguments to be expected.

Because you can have multiple arguments associated with one custom "fmt" specification this has to be the last argument to every call to vstr_fmt_add().

Just specifying this type means that there are no arguments used, by the custom "fmt" specification.

This flag means that vstr_add_vfmt() should expect a "int" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect an "unsigned int" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "long" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect an "unsigned long" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "long long" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect an "unsigned long long" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "ssize_t" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "size_t" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "ptrdiff_t" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "intmax_t" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "uintmax_t" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "double" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "long double" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "void *" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "char *" type from the argument list passed to it

This flag means that vstr_add_vfmt() should expect a "wchar_t *" type from the argument list passed to it

This flag means that vstr_add_vfmt() should not expect any arguments passed, but should set the value of errno, just before calling the user callback, to the value upon entering vstr_add_vfmt().

Constants passed to vstr_sc_fmt_cb_beg()

This flag is the same as just specifying VSTR_FLAG_SC_FMT_CB_BEG_OBJ_STR.

This flag indicates that the object should be treated as a C style string, so it is assumed that number orientated flags should be ignored and that the length of the object can be arbitrarily truncated.

This flag indicates that the object should be treated as an atomic piece of data, so it is assumed that number orientated flags should be ignored and that the length of the object can't be truncated.

This flag indicates that the object you are printing should be treated as a number. For instance setting a precision will truncate the length of the object, unless it is a number. Also +/-/ leaders and zero padding will only be done for numbers.

This flag indicates that the number object you are printing should be treated as negative number. This flag has no meaning if VSTR_FLAG_SC_FMT_CB_BEG_OBJ_NUM is not set.

Constants passed to vstr_conv_unprintable_del() and vstr_conv_unprintable_chr()

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

Because it is sometimes hard are to notice certain characters, they are classified as "unprintable" by default, the value VSTR_FLAG_CONV_UNPRINTABLE_DEF is a default that is what most people would expect to be classified as unprintable.

This flag allows the ASCII 0x00 byte, aka. NULL, through as a "printable" character.

This flag allows the ASCII 0x07 byte, aka. terminal bell, through as a "printable" character.

This flag allows the ASCII 0x08 byte, aka. backspace, through as a "printable" character.

This flag allows the ASCII 0x09 byte, aka. horizontal tab, through as a "printable" character.

This flag allows the ASCII 0x0A byte, aka. line feed, through as a "printable" character.

This flag allows the ASCII 0x0B byte, aka. vertical tab, through as a "printable" character.

This flag allows the ASCII 0x0C byte, aka. form feed, through as a "printable" character.

This flag allows the ASCII 0x0D byte, aka. carriage return, through as a "printable" character.

This flag allows the ASCII 0x20 byte, aka. space, through as a "printable" character.

This flag allows the ASCII 0x2C byte, aka. comma, through as a "printable" character.

This flag allows the ASCII 0x2E byte, aka. dot, through as a "printable" character.

This flag allows the ASCII 0x5F byte, aka. underbar, through as a "printable" character.

This flag allows the ASCII 0x1B byte, aka. escape, through as a "printable" character.

This flag allows the ASCII 0x7F byte, aka. delete, through as a "printable" character.

This flag allows the ASCII 0xA0 byte through as a "printable" character.

The value 0xA0 is 0x20 with the high bit set, and this character it often printed as space when in an ASCII like encoding.

This flag allows the all ASCII bytes greater than or equal to 0xA1 through as "printable" characters.

This includes all the extra characters like not, degree, copyright and micro when in an ASCII like encoding.

This flag is the same as using the flags for space, comma, dot and underbar. Using just this flag is probably what you'd expect an "unprintable" function to do.

This error code has the value 0, and means that no error occurred parsing the number from the Vstr string.

This error code means that the Vstr string consisted only of spaces.

This error code means that the Vstr string consisted only spaces, and a plus or minus sign.

This error code means that the Vstr string consisted only spaces, a plus or minus sign and a "0x" base 16 prefix.

This error code means that the Vstr string had characters in it that where out of bounds from the working set.

This out of bounds includes the Vstr string "++" as well as "4A", when parsing in a base less than 11.

This error code means that the number parsed from the Vstr string would overflow the type it is being parsed into, this is only returned when the VSTR_FLAG_PARSE_NUM_OVERFLOW flag was passed to the parse function.

This error code means that the number parsed from the Vstr string starts with a '-' (Hyphen) character when it is supposed to be an unsigned type.

This error code means that the number parsed from the Vstr string starts with a '0' (Digit Zero) character, when the VSTR_FLAG_PARSE_NUM_NO_BEG_ZERO flag was passed to the parse function.

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

This flag changes the parsing from ASCII numbers into "local" numbers (whatever is generated by '0 .. '9' by the host compiler). This can be ignored by anyone not using an EBCDIC character set, or something equally weird.

This flag allows the parsing of the '_' (Low Line) separator character between the digits of the number, so "1234" and "1_234" would both parse the same.

The separator is only allowed within the digits of the number, so " _+_1234" would fail as would "_1234".

This flag turns on the overflow checking, in other words without it VSTR_TYPE_PARSE_NUM_ERR_OVERFLOW will never be returned as an error code.

The return value with this set is the highest number that can be parsed from the beginning of the Vstr string, while the value without this flag would be the parsed number modulo the highest number of the type.

For example given a type that had a maximum of 10, then parsing "64" would give you 6 with the flag, and 4 without.

This flag allows one or more ' ' (Space) characters before the number or number prefix (Plus Sign, Hyphen).

This flag disallows one or more '0' (Digit Zero) characters before the number.

This flag disallows a plus or a minus character before the number.

Constants passed to vstr_parse_ipv4()

This error code has the value 0, and means that no error occurred parsing the ipv4 address from the Vstr string.

This error code means that the numbers for the ipv4 address in the Vstr string where out of bounds.

This error code means that the ipv4 address wasn't full (Ie. 127/8 is a non full ipv4 address with CIDR mask).

This error code means that the ipv4 address, and option mask, wasn't the only thing in the Vstr string.

When this error code is returned, the ip address is still parsed out and as usable as if no error had occurred.

This error code means that the numbers for the ipv4 CIDR mask in the Vstr string where out of bounds.

This error code means that the ipv4 CIDR mask wasn't full (Ie. 127.0.0.1/ is an ipv4 address with a non full ipv4 CIDR mask).

This error code means that the numbers for the ipv4 netmask in the Vstr string where out of bounds.

This error code means that the ipv4 CIDR mask wasn't full (Ie. 127.0.0.1/255.0 is an ipv4 address with a non full ipv4 netmask).

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

This flag changes the parsing from ASCII numbers into "local" numbers (whatever is generated by '0 .. '9' by the host compiler). This can be ignored by anyone not using an EBCDIC character set, or something equally weird.

This flag allows the use of leading zeros in the ipv4 address and masks.

This flag changes the parsing so that the function will return an error if a non full ipv4 address is given (Ie. 127/8 is a non full ipv4 with a CIDR mask). If this flag isn't given the missing numbers are assumed to be zero.

This flag allows the parsing out of a CIDR mask, if one is present.

This flag changes the parsing so that the function will return an error if a non full ipv4 CIDR mask is given (Ie. 127.0.0.1/ is an ipv4 with a non full ipv4 CIDR mask). If this flag isn't given the missing CIDR mask is assumed to be 32.

This flag allows the parsing out of a ipv4 netmask, if one is present.

If both this and the VSTR_FLAG_PARSE_IPV4_CIDR flag is given, then either masking interface will be parsed out as no valid CIDR value is a valid netmask prefix.

This flag changes the parsing so that the function will return an error if a non full ipv4 CIDR mask is given (Ie. 127.0.0.1/255.0 is an ipv4 with a non full ipv4 netmask). If this flag isn't given the missing numbers are assumed to be zero.

This flag changes the parsing so that the function will return an error if the entire string isn't used to contain the ipv4 and option mask.

When this error code is returned, the ip address is still parsed out and as usable as if no error had occurred.

Constants passed to vstr_parse_ipv6()

This error code has the value 0, and means that no error occurred parsing the ipv6 address from the Vstr string.

This error code means that the numbers for the ipv6 address in the Vstr string where out of bounds.

This error code means that the ipv6 address wasn't full (Ie. FFFF/8 is a non full ipv6 address with CIDR mask).

This error code means that the ipv6 address, and option mask, wasn't the only thing in the Vstr string.

When this error code is returned, the ip address is still parsed out and as usable as if no error had occurred.

This error code means that the numbers for the ipv6 CIDR mask in the Vstr string where out of bounds.

This error code means that the ipv6 CIDR mask wasn't full (Ie. F::1/ is an ipv6 address with a non full ipv6 CIDR mask).

This error code means that there is more than one "NULL" point in the ipv6 address, for example "F::E::1" has two NULL points and is impossible to parse.

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

This flag changes the parsing from ASCII numbers into "local" numbers (whatever is generated by '0 .. '9' by the host compiler). This can be ignored by anyone not using an EBCDIC character set, or something equally weird.

This flag allows the parsing out of a CIDR mask, if one is present.

This flag changes the parsing so that the function will return an error if a non full ipv6 CIDR mask is given (Ie. ::1/ is an ipv6 with a non full ipv6 CIDR mask). If this flag isn't given the missing CIDR mask is assumed to be 32.

This flag changes the parsing so that the function will return an error if the entire string isn't used to contain the ipv6 and option mask.

When this error code is returned, the ip address is still parsed out and as usable as if no error had occurred.

This flag outputs the ipv6 address as 8 groups of 4 hexadecimal values. For example "FFFF:0EEE:00DD:000C:0000:0000:0001:0002" would be an ipv6 address output in aligned mode.

This flag outputs the ipv6 address in as small a representation as possible, for example "FFFF:EEE:DD:C::1:2" would be an ipv6 address output in compact mode.

This flag outputs the ipv6 address as 8 groups of hexadecimal numbers between 0 and FFFF, this is the format mostly used in standards. documents, for example "FFFF:EEE:DD:C:0:0:1:2" would be an ipv6 address output in compact mode.

This flag outputs the ipv6 address in the same way as VSTR_TYPE_SC_FMT_CB_IPV6_ALIGNED, except that the last 2 groups of hexadecimal values (the last 4 octets) are replaced with an ipv4 address.

This flag outputs the ipv6 address in the same way as VSTR_TYPE_SC_FMT_CB_IPV6_COMPACT, except that the last 2 groups of hexadecimal values (the last 4 octets) are replaced with an ipv4 address.

This flag outputs the ipv6 address in the same way as VSTR_TYPE_SC_FMT_CB_IPV6_STD, except that the last 2 groups of hexadecimal values (the last 4 octets) are replaced with an ipv4 address.

Constants passed to vstr_split_buf() , vstr_split_cstr_buf() , VSTR_SPLIT_CSTR_BUF(), vstr_split_chrs() , vstr_split_cstr_chrs() and VSTR_SPLIT_CSTR_CHRS()

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

This flag allows the split functions to add sections at the beginning of the input that have a null string before the match. For example the input "::abcd:..." split on ":" would have 2 sections at positions 1 and 2 of length 0, without this flag the first section would be at position 3 with length 4.

This flag allows the split functions to add sections in the middle of the input that have a null string between 2 matches. For example the input "a::abcd:..." split on ":" would have the second section at position 3 of length 0, without this flag the second section would be at position 4 of length 4.

This flag allows the split functions to add sections at the end of the input that have a null string after a match. For example the input "a::" split on ":" would have the second section at position 3 of length 0, without this flag there would only be one section added.

This flag allows the split functions to add a final post section of the input that ends with a match. For example the input "a:" split on ":" would have the second section at position 3 (outside the range of the input) of length 0, without this flag there would only be one section added.

This flag allows the split functions to return 1, when the Vstr sections doesn't have any more room. Without the flag the split functions would calculate the number of splits that would have been added if there was room in the Vstr sections.

This flag changes the split functions, when used with a limit, so that the last section added is for the remainder of the input.

Constants passed to vstr_sects_foreach()

This flag is 0, and is generally only used as programmer documentation to mean no flags are applied to this function.

This flag changes the foreach function so that it goes through the sections backward (from the end to the beginning).

This flag changes the foreach function so that it calls the foreach callback on sections of null length (a non zero position with a zero length).

This return value is 0, and is generally only used as programmer documentation to mean nothing special should happen on return from the callback.

This return value tells the foreach function to delete the current section before the next callback is called.

This return value tells the foreach function to return immediately (it does the same thing as a break statement in a C for loop.

Constants used with the callback from vstr_cache_add_cb()

This type means that an add operation has just happened on the Vstr string, the position and length arguments are as taken from one of the vstr_add_* functions.

This type means that a delete operation has just happened on the Vstr string, the position and length arguments are as taken from the vstr_del() function.

This type means that a substitute operation has just happened on the Vstr string, the position and length arguments are as taken from one of the vstr_sub_* functions.

This type means that the data in the cache needs to be free()'d, the callback should always return NULL when this type is passed in.

The position and length arguments are undefined.

Constants passed to vstr_sc_mmap_fd() and vstr_sc_mmap_file()

This error code has the value 0, and means that no error occurred adding the mapping into the Vstr string.

This error code means that the call to open() returned -1, errno is set.

This error code means that the call to fstat() returned -1, errno is set.

This error code means that the call to mmap() returned -1, errno is set.

This error code means that the call to close() returned -1, errno is set.

Even though this is an error, the mapping has already occurred and was successful.

If another error occurred (Eg. fstat()/mmap()), then any errors from close() will be hidden.

This error code means that memory could not be allocated.

To help the programer unify error paths base->conf->malloc_bad is set to TRUE, and errno is set to ENOMEM.

This error code means that the memory mapping was too big to fit in the Vstr string (with LFS extensions files are 63 bits, while on a 32 bit computer memory space is still only 32 bits so this isn't a corner case).

To help the programer unify error paths errno is set to EFBIG.

Constants passed to vstr_sc_read_iov_fd() , vstr_sc_read_len_fd() , vstr_sc_read_iov_file() and vstr_sc_read_len_file()

This error code has the value 0, and means that no error occurred adding the read() data into the Vstr string.

This error code means that the call to open() returned -1, errno is set.

This error code means that the call to fstat() returned -1, errno is set.

This error code means that the call to lseek() returned -1, errno is set.

This error code means that the call to readv() returned -1, errno is set.

This error code means that the call to close() returned -1, errno is set.

Even though this is an error, the readv() has already occurred and was successful.

If another error occurred (Eg. fstat()/readv()), then any errors from close() will be hidden.

This error code means that the call to readv() returned 0.

To help the programer unify error paths errno is set to ENOSPC.

This error code means that memory could not be allocated.

To help the programer unify error paths base->conf->malloc_bad is set to TRUE, and errno is set to ENOMEM.

This error code means that the memory mapping was too big to fit in the Vstr string (with LFS extensions files are 63 bits, while on a 32 bit computer memory space is still hard limited to 32 bits so this isn't a corner case).

To help the programer unify error paths errno is set to EFBIG.

Constants passed to vstr_sc_write_fd() and vstr_sc_write_file()

This error code has the value 0, and means that no error occurred adding the read() data into the Vstr string.

This error code means that the call to lseek() returned -1, errno is set.

This error code means that the call to open() returned -1, errno is set.

This error code means that the call to writev() returned -1, errno is set.

This error code means that the call to close() returned -1, errno is set.

Even though this is an error, the mapping has already occurred and happened successfully.

If another error occurred (Eg. writev()), then any errors from close() will be hidden.

This error code means that memory could not be allocated.

To help the programer unify error paths base->conf->malloc_bad is set to TRUE, and errno is set to ENOMEM.

Constants passed to vstr_cntl_base()

This option will get the Vstr configuration for the Vstr string

This option will set the Vstr configuration for the Vstr string.

This will only return successfully if either the Vstr string is empty, or the Vstr configurations have the same value for the NUM_BUF_SZ attribute.

If the Vstr configuration (Parameter[1]) is NULL, then the default Vstr configuration will be used.

This option lets you know if the Vstr string can cache data, this can only be controlled using the VSTR_CNTL_CONF_GET_FLAG_ALLOC_CACHE flag.

Constants passed to vstr_cntl_conf()

This option will get the size of the allocated portion of a _BUF type node.

This option will set the size of the allocated portion of a _BUF type node.

This will fail if Vstr strings are using the Vstr configuration.

The value cannot be higher than VSTR_MAX_NODE_BUF.

This option will get the size of the minimum allocation to do when expanding the iovec cache.

This option will set the size of the minimum allocation to do when expanding the iovec cache.

This option will get the offset on the iovec cache after an iovec allocation.

This option will set the offset on the iovec cache after an iovec allocation.

This option will get the number of references to the Vstr configuration.

This option will set the LC_NUMERIC variables in the Vstr configuration to be those specified in the system locale (Parameter[1]).

Passing NULL as the name will use the current system LC_NUMERIC locale.

This option will get the name of the LC_NUMERIC locale.

This option will set the name of the LC_NUMERIC locale.

This option will get the value of the decimal point LC_NUMERIC locale variable.

This option will set the value of the decimal point LC_NUMERIC locale variable.

This option will get the value of the thousands separator LC_NUMERIC locale variable.

This option will set the value of the thousands separator LC_NUMERIC locale variable.

This option will get the value of the thousands grouping LC_NUMERIC locale variable.

This option will set the value of the thousands grouping LC_NUMERIC locale variable.

This option will return the status of the flag that allows the vstr functions to update the iovec cache when doing add/del operations on Vstr strings.

This option will allow the vstr functions to update the iovec cache when doing add/del operations on Vstr strings.

This option will return the status of the flag that allows the vstr functions to split _BUF nodes on del operations to Vstr strings.

This option will allow the vstr functions to split _BUF nodes on a del operations to Vstr strings.

This option will return the status of the flag that allows Vstr strings to cache data.

This option will allow the Vstr strings made from the Vstr configuration to cache data.

If this option is turned off vstr_cache_add_cb() will not work on Vstr strings made from the the Vstr configuration. However each Vstr string will become smaller due to the lack of cache.

This option will return the character used for specifying custom format specifiers in the vstr_add_vfmt() function.

This option will allow the Vstr strings using the Vstr configuration to use custom format specifiers in the vstr_fmt_vfmt() function.

If this option is set to 0 ('\0') then vstr_fmt_vfmt() acts like vstr_fmt_vsysfmt().

This option gets the current number of spare nodes of the specified type.

This option is will set the number of spare nodes of the specified type, by calling either vstr_make_spare_nodes() or vstr_free_spare_nodes().

When the value specified is higher and it calls vstr_make_spare_nodes() then a return value of FALSE means that there was a malloc error, just as if you called vstr_make_nodes directly.

This option will return the status of the flag that makes the vstr functions do atomic alterations to the string data. If the flag is set then all functions will either return successfully, or not alter the data of the vstr from the point of view of vstr_cmp().

This is mainly a speedup to the vstr_sub_*() functions and the functions that use them, like vstr_conv_*(). It is true by default, so all function operations are atomic.

This option will set the status of the flag that makes the vstr functions do atomic alterations to the string data. If the flag is set then all functions will either return successfully, or not alter the data of the vstr from the point of view of vstr_cmp().

This is mainly a speedup to the vstr_sub_*() functions and the functions that use them, like vstr_conv_*(). It is true by default, so all function operations are atomic.

This option will make the number of spare nodes of the specified type fit into the range given, by calling either vstr_make_spare_nodes() or vstr_free_spare_nodes().

When the value specified is higher and it calls vstr_make_spare_nodes() then a return value of FALSE means that there was a malloc error, just as if you called vstr_make_nodes directly.

Constants passed to vstr_cntl_opt()

This option will get the default Vstr configuration.

This option will set the default Vstr configuration.