summaryrefslogtreecommitdiff
path: root/support/dktools/dk3enc.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /support/dktools/dk3enc.c
Initial commit
Diffstat (limited to 'support/dktools/dk3enc.c')
-rw-r--r--support/dktools/dk3enc.c1880
1 files changed, 1880 insertions, 0 deletions
diff --git a/support/dktools/dk3enc.c b/support/dktools/dk3enc.c
new file mode 100644
index 0000000000..384db91bd5
--- /dev/null
+++ b/support/dktools/dk3enc.c
@@ -0,0 +1,1880 @@
+/*
+ WARNING: This file was generated by dkct.
+ Changes you make here will be lost if dkct is run again!
+ You should modify the original source and run dkct on it.
+ Original source: dk3enc.ctr
+*/
+
+/*
+Copyright (C) 2011-2017, Dirk Krause
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above opyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+* Neither the name of the author nor the names of contributors may be used
+ to endorse or promote products derived from this software without specific
+ prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, 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 dk3enc.c The dk3enc module.
+*/
+
+
+#line 312 "dk3enc.ctr"
+
+#include "dk3all.h"
+
+
+
+
+
+#line 317 "dk3enc.ctr"
+
+
+
+/** Binary to text encoding names.
+ Order here must match order of DK3_DATA_ENCODING_xxx in dk3const.h.
+*/
+static dkChar const * const dk3enc_data_encoding_names[] = {
+/* 0 */ dkT("HEX"),
+/* 1 */ dkT("ASCII-85"),
+/* 2 */ dkT("R-ASCII-85"),
+/* 3 */ dkT("H"),
+/* 4 */ dkT("A"),
+/* 5 */ dkT("R"),
+/* 6 */ dkT("A85"),
+/* 7 */ dkT("RA85"),
+NULL
+};
+
+
+
+/** Encoding names for file contents encodings.
+*/
+static dkChar const * const dk3enc_text_encoding_names[] = {
+/* 0 */ dkT("PLAIN"),
+/* 1 */ dkT("UTF-8"),
+/* 2 */ dkT("UTF-16"),
+/* 3 */ dkT("UTF-16.MSB"),
+/* 4 */ dkT("UTF-16.LSB"),
+/* 5 */ dkT("UC32"),
+/* 6 */ dkT("UC32.MSB"),
+/* 7 */ dkT("UC32.LSB"),
+/* 8 */ dkT("ASCII"),
+/* 9 */ dkT("ISO-LATIN-1"),
+/* 10 */ dkT("UTF8"),
+/* 11 */ dkT("UTF16"),
+/* 12 */ dkT("UTF-16-LE"),
+/* 13 */ dkT("UTF-16LE"),
+/* 14 */ dkT("UTF16LE"),
+/* 15 */ dkT("UTF-16-LSB"),
+/* 16 */ dkT("UTF-16LSB"),
+/* 17 */ dkT("UTF16LSB"),
+/* 18 */ dkT("UTF-16-BE"),
+/* 19 */ dkT("UTF-16BE"),
+/* 20 */ dkT("UTF16BE"),
+/* 21 */ dkT("UTF-16-MSB"),
+/* 22 */ dkT("UTF-16MSB"),
+/* 23 */ dkT("UTF16MSB"),
+/* 24 */ dkT("C32"),
+/* 25 */ dkT("C32-LE"),
+/* 26 */ dkT("C32LE"),
+/* 27 */ dkT("C32-LSB"),
+/* 28 */ dkT("C32LSB"),
+/* 29 */ dkT("C32-BE"),
+/* 30 */ dkT("C32BE"),
+/* 31 */ dkT("C32-MSB"),
+/* 32 */ dkT("C32MSB"),
+NULL
+};
+
+
+
+/** Encoding names for UTF-8 encoding.
+*/
+static char const * const dk3enc_utf8_names[] = {
+/* 0 */
+"utf-8",
+
+/* 1 */
+"utf8",
+
+NULL
+
+
+#line 385 "dk3enc.ctr"
+};
+
+
+/** Digits used to show hexadecimal characters.
+*/
+static char const dk3enc_hex_digits[] = {
+'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '\0'
+};
+
+
+/** Bit mask to obtain last byte of a double word.
+*/
+static unsigned long const dk3enc_last_byte = 0x000000FFUL;
+
+
+
+/** Factors for ASCII85 and reverse ASCII85 encoding.
+*/
+static unsigned long const dk3enc_f2[] = {
+ 1UL,
+ 85UL,
+ (85UL * 85UL),
+ (85UL * 85UL * 85UL),
+ (85UL * 85UL * 85UL * 85UL)
+};
+
+
+
+/** Swap byte order for unsigned long.
+ @param ul Original value.
+ @return Value in swapped byte order.
+*/
+static
+unsigned long
+dk3enc_swap_ul(unsigned long ul)
+{
+ unsigned long back = 0UL;
+ back = ((ul >> 24) & 0x000000FFUL);
+ back |= ((ul >> 8) & 0x0000FF00UL);
+ back |= ((ul << 8) & 0x00FF0000UL);
+ back |= ((ul << 24) & 0xFF000000UL);
+ return back;
+}
+
+
+
+/** Swap byte order for unsigned short.
+ @param us Original value.
+ @return Value in swapped byte order.
+*/
+static
+unsigned short
+dk3enc_swap_us(unsigned short us)
+{
+ unsigned short back = 0U;
+ back = ((us >> 8) & 0x00FFU);
+ back |= ((us << 8) & 0xFF00U);
+ return back;
+}
+
+
+unsigned long
+dk3enc_ntohl(unsigned long x)
+{
+ unsigned long back;
+#if DK3_WORDS_BIGENDIAN
+ back = x;
+#else
+ back = dk3enc_swap_ul(x);
+#endif
+ return back;
+}
+
+
+unsigned long
+dk3enc_htonl(unsigned long x)
+{
+ unsigned long back;
+#if DK3_WORDS_BIGENDIAN
+ back = x;
+#else
+ back = dk3enc_swap_ul(x);
+#endif
+ return back;
+}
+
+
+
+unsigned short
+dk3enc_ntohs(unsigned short x)
+{
+ unsigned short back;
+#if DK3_WORDS_BIGENDIAN
+ back = x;
+#else
+ back = dk3enc_swap_us(x);
+#endif
+ return back;
+}
+
+
+
+unsigned short
+dk3enc_htons(unsigned short x)
+{
+ unsigned short back;
+#if DK3_WORDS_BIGENDIAN
+ back = x;
+#else
+ back = dk3enc_swap_us(x);
+#endif
+ return back;
+}
+
+
+
+/** Convert 32-bit character to UTF-8 following RFC2279.
+ @param c 32-bit character to convert.
+ @param u8p Destination buffer.
+ @param u8l Length of @a u8p (number of bytes).
+ @return Number of bytes written to @a u8p.
+*/
+static
+size_t
+dk3enc_uc2utf8_rfc2279(dk3_c32_t c, unsigned char *u8p, size_t u8l)
+{
+ size_t back = 0;
+ dk3_c32_t x = 0UL; /* Variable for temporary results. */
+
+
+#line 514 "dk3enc.ctr"
+ if(u8p) {
+ if(u8l > 0) {
+ if(c > (dk3_c32_t)0x7FUL) {
+ if(c > (dk3_c32_t)0x000007FFUL) {
+ if(c > (dk3_c32_t)0x0000FFFFUL) {
+ if(c > (dk3_c32_t)0x001FFFFFUL) {
+ if(c > (dk3_c32_t)0x03FFFFFFUL) {
+ if(c < (dk3_c32_t)0x80000000UL) { /* 6 Byte */
+ if(u8l >= 6) {
+ back = 6;
+ x = c >> 30;
+ x &= 0x00000001UL;
+ x |= 0x000000FCUL;
+ u8p[0] = (unsigned char)x;
+ x = c >> 24; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[1] = (unsigned char)x;
+ x = c >> 18; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[2] = (unsigned char)x;
+ x = c >> 12; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[3] = (unsigned char)x;
+ x = c >> 6; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[4] = (unsigned char)x;
+ x = c & 0x0000003FUL; x |= 0x00000080UL;
+ u8p[5] = (unsigned char)x;
+ }
+ }
+ } else { /* 5 Byte */
+ if(u8l >= 5) {
+ back = 5;
+ x = c >> 24;
+ x &= 0x00000003UL;
+ x |= 0x000000F8UL;
+ u8p[0] = (unsigned char)x;
+ x = c >> 18; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[1] = (unsigned char)x;
+ x = c >> 12; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[2] = (unsigned char)x;
+ x = c >> 6; x &= 0x0000003FUL; x |= 0x00000080UL;
+ u8p[3] = (unsigned char)x;
+ x = c & 0x0000003FUL; x |= 0x00000080UL;
+ u8p[4] = (unsigned char)x;
+ }
+ }
+ } else { /* 4 Byte */
+ if(u8l >= 4) {
+ back = 4;
+ x = c >> 18;
+ x &= 0x00000007UL;
+ x |= 0x000000F0UL;
+ u8p[0] = (unsigned char)x;
+ x = c >> 12;
+ x &= 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[1] = (unsigned char)x;
+ x = c >> 6;
+ x &= 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[2] = (unsigned char)x;
+ x = c & 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[3] = (unsigned char)x;
+ }
+ }
+ } else { /* 3 Byte */
+ if(u8l >= 3) {
+ back = 3;
+ x = c >> 12;
+ x &= 0x0000000FUL;
+ x |= 0x000000E0UL;
+ u8p[0] = (unsigned char)x;
+ x = c >> 6;
+ x &= 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[1] = (unsigned char)x;
+ x = c & 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[2] = (unsigned char)x;
+ }
+ }
+ } else { /* 2 Byte */
+ if(u8l >= 2) {
+ back = 2;
+ x = c >> 6;
+ x &= 0x0000001FUL;
+ x |= 0x000000C0UL;
+ u8p[0] = (unsigned char)x;
+ x = c & 0x0000003FUL;
+ x |= 0x00000080UL;
+ u8p[1] = (unsigned char)x;
+ }
+ }
+ } else { /* 1 Byte */
+ if(u8l >= 1) {
+ back = 1;
+ u8p[0] = (unsigned char)(c & 0x0000007FUL);
+ }
+ }
+ }
+ }
+
+#line 613 "dk3enc.ctr"
+ return back;
+}
+
+
+
+/** Get one 32-bit character from UTF-8 encoded string or buffer.
+ @param ucp Pointer to destination variable.
+ @param u8p Buffer containing UTF-8 encoded data.
+ @param u8l Length of @a u8p (number of bytes).
+ @param u8u Pointer to variable for used bytes from @a u8p.
+ @return 1 on success, 0 on error.
+*/
+static
+int
+dk3enc_utf82uc_rfc2279(
+ dk3_c32_t *ucp, unsigned char const *u8p,size_t u8l,size_t *u8u
+)
+{
+ int back = 0;
+ unsigned char u1 = 0x00; /* Character to process. */
+ dk3_c32_t res = 0UL; /* Result. */
+ dk3_c32_t x1 = 0UL; /* Result component from 1st byte. */
+ dk3_c32_t x2 = 0UL; /* Result component from 2nd byte. */
+ dk3_c32_t x3 = 0UL; /* Result component from 3rd byte. */
+ dk3_c32_t x4 = 0UL; /* Result component from 4th byte. */
+ dk3_c32_t x5 = 0UL; /* Result component from 5th byte. */
+ dk3_c32_t x6 = 0UL; /* Result component from 6th byte. */
+ size_t needed_length = 0; /* Number of btes needed. */
+
+
+#line 642 "dk3enc.ctr"
+ needed_length = 0;
+ if(ucp) {
+ if(u8p) {
+ if(u8l) {
+ if(u8u) {
+ if((u8l) > 0) {
+ u1 = *u8p; needed_length = 1;
+ if(u1 > 0x7F) { /* > 1 Byte */
+ if((u1 & 0xE0) == 0xC0) { /* 2 Byte */
+ needed_length = 2;
+ if(u8l >= needed_length) {
+ if((u8p[1] & 0xC0) == 0x80) {
+ x1 = u1;
+ x1 = x1 << 6;
+ x1 = x1 & 0x000007C0UL;
+ x2 = u8p[1];
+ x2 = x2 & 0x0000003FUL;
+ res = (x1 | x2); back = 1;
+ }
+ }
+ } else {
+ if((u1 & 0xF0) == 0xE0) { /* 3 Byte */
+ needed_length = 3;
+ if(u8l >= needed_length) {
+ if((u8p[1] & 0xC0) == 0x80) {
+ if((u8p[2] & 0xC0) == 0x80) {
+ x1 = u1;
+ x1 = x1 << 12;
+ x1 = x1 & 0x0000F000UL;
+ x2 = u8p[1];
+ x2 = x2 << 6;
+ x2 = x2 & 0x00000FC0UL;
+ x3 = u8p[2];
+ x3 = x3 & 0x0000003FUL;
+ res = (x1 | x2 | x3); back = 1;
+ }
+ }
+ }
+ } else {
+ if((u1 & 0xF8) == 0xF0) { /* 4 Byte */
+ needed_length = 4;
+ if(u8l >= needed_length) {
+ if((u8p[1] & 0xC0) == 0x80) {
+ if((u8p[2] & 0xC0) == 0x80) {
+ if((u8p[3] & 0xC0) == 0x80) {
+ x1 = u1;
+ x2 = u8p[1];
+ x3 = u8p[2];
+ x4 = u8p[3];
+ x1 = x1 << 18;
+ x1 = x1 & 0x001C0000UL;
+ x2 = x2 << 12;
+ x2 = x2 & 0x0003F000UL;
+ x3 = x3 << 6;
+ x3 = x3 & 0x00000FC0UL;
+ x4 = x4 & 0x0000003FUL;
+ res = (x1 | x2 | x3 | x4); back = 1;
+ }
+ }
+ }
+ }
+ } else {
+ if((u1 & 0xFC) == 0xF8) { /* 5 Byte */
+ needed_length = 5;
+ if(u8l >= needed_length) {
+ if((u8p[1] & 0xC0) == 0x80) {
+ if((u8p[2] & 0xC0) == 0x80) {
+ if((u8p[3] & 0xC0) == 0x80) {
+ if((u8p[4] & 0xC0) == 0x80) {
+ x1 = u1;
+ x2 = u8p[1];
+ x3 = u8p[2];
+ x4 = u8p[3];
+ x5 = u8p[4];
+ x1 = x1 << 24;
+ x1 = x1 & 0x03000000UL;
+ x2 = x2 << 18;
+ x2 = x2 & 0x00FC0000UL;
+ x3 = x3 << 12;
+ x3 = x3 & 0x0003F000UL;
+ x4 = x4 << 6;
+ x4 = x4 & 0x00000FC0UL;
+ x5 = x5 & 0x0000003FUL;
+ res = (x1 | x2 | x3 | x4 | x5); back = 1;
+ }
+ }
+ }
+ }
+ }
+ } else {
+ if((u1 & 0xFE) == 0xFC) { /* 6 Byte */
+ needed_length = 6;
+ if(u8l >= needed_length) {
+ if((u8p[1] & 0xC0) == 0x80) {
+ if((u8p[2] & 0xC0) == 0x80) {
+ if((u8p[3] & 0xC0) == 0x80) {
+ if((u8p[4] & 0xC0) == 0x80) {
+ if((u8p[5] & 0xC0) == 0x80) {
+ x1 = 0x40000000UL;
+ x2 = u8p[1]; x3 = u8p[2]; x4 = u8p[3];
+ x5 = u8p[4]; x6 = u8p[5];
+ x2 = x2 << 24;
+ x3 = x3 << 18;
+ x4 = x4 << 12;
+ x5 = x5 << 6;
+ x2 = x2 & 0x3F000000UL;
+ x3 = x3 & 0x00FC0000UL;
+ x4 = x4 & 0x0003F000UL;
+ x5 = x5 & 0x00000FC0UL;
+ x6 = x6 & 0x0000003FUL;
+ res = (x1 | x2 | x3 | x4 | x5 | x6);
+ back = 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ } else { /* 1 Byte */
+ res = u1;
+ back = 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ if(back) {
+ *u8u = needed_length;
+ *ucp = res;
+ }
+
+#line 778 "dk3enc.ctr"
+ return back;
+}
+
+
+
+#if DK3_HAVE_RFC_2279
+
+/*
+ RFC 2279 allowed UTF-8 encoding for 32-bit characters in the
+ range 0 ... 0x7FFFFFFF.
+*/
+
+size_t
+dk3enc_uc2utf8(dk3_c32_t c, unsigned char *u8p, size_t u8l)
+{
+ size_t back;
+
+
+#line 795 "dk3enc.ctr"
+ back = dk3enc_uc2utf8_rfc2279(c, u8p, u8l);
+
+
+#line 797 "dk3enc.ctr"
+ return back;
+}
+
+int
+dk3enc_utf82uc(dk3_c32_t *ucp, unsigned char const *u8p,size_t u8l,size_t *u8u)
+{
+ int back;
+ back = dk3enc_utf82uc_rfc2279(ucp, u8p, u8l, u8u);
+ return back;
+}
+
+
+#else
+
+/*
+ RFC 3629 replaces (obsoletes) RFC 2279.
+ 32-bit characters are now allowed in the range
+ 0 ... 0x0010FFFF only.
+*/
+
+size_t
+dk3enc_uc2utf8(dk3_c32_t c, unsigned char *u8p, size_t u8l)
+{
+ size_t back = 0;
+
+
+#line 822 "dk3enc.ctr"
+ if(c <= (dk3_c32_t)0x0010FFFFUL) {
+ back = dk3enc_uc2utf8_rfc2279(c, u8p, u8l);
+ }
+
+#line 825 "dk3enc.ctr"
+ return back;
+}
+
+int
+dk3enc_utf82uc(dk3_c32_t *ucp, unsigned char const *u8p,size_t u8l,size_t *u8u)
+{
+ int back = 0;
+ back = dk3enc_utf82uc_rfc2279(ucp, u8p, u8l, u8u);
+ if(back) {
+ if((*ucp) > (dk3_c32_t)0x0010FFFFUL) {
+ back = 0;
+ }
+ }
+ return back;
+}
+
+#endif
+
+
+
+size_t
+dk3enc_uc2utf16(dk3_c32_t c, dk3_c16_t *u16p, size_t u16l)
+{
+ size_t back = 0;
+ dk3_c32_t ul = 0UL; /* Low surrogate. */
+ dk3_c32_t um = 0UL; /* Hight surrogate. */
+ if((u16p) && (u16l)) {
+ if(c >= (dk3_c32_t)0x00010000UL) {
+ if(c <= (dk3_c32_t)0x0010FFFFUL) {
+ if(u16l >= 2) {
+ ul = c - 0x00010000UL;
+ um = ((ul >> 10) & 0x000003FFUL);
+ um |= 0x0000D800UL;
+ u16p[0] = (dk3_c16_t)um;
+ um = (ul & 0x000003FFUL);
+ um |= 0x0000DC00UL;
+ u16p[1] = (dk3_c16_t)um;
+ back = 2;
+ }
+ }
+ } else {
+#if VERSION_BEFORE_20141125
+ if((c & 0x0000DC00UL) != 0x0000DC00UL) {
+ if((c & 0x0000DC00UL) != 0x0000D800UL) {
+ *u16p = (dk3_c16_t)c; back = 1;
+ }
+ }
+#else
+ if ((0x0000D800UL > c) || (0x0000DFFF < c)) {
+ *u16p = (dk3_c16_t)c; back = 1;
+ }
+#endif
+ }
+ }
+ return back;
+}
+
+
+
+int
+dk3enc_utf162uc(dk3_c32_t *ucp, dk3_c16_t const *u16p, size_t u16l, size_t *u16u)
+{
+ int back = 0;
+ dk3_c32_t result = 0UL; /* Result 32-bit character. */
+ dk3_c32_t ul1 = 0UL; /* First UC16 used. */
+ dk3_c32_t ul2 = 0UL; /* Second UC16 used (if any). */
+
+ if((ucp) && (u16p) && (u16l) && (u16u)) {
+ *u16u = 0;
+ ul1 = (((dk3_c32_t)(u16p[0])) & 0x0000FFFFUL);
+ ul2 = 0UL;
+ if(u16l > 1) {
+ ul2 = (((dk3_c32_t)(u16p[1])) & 0x0000FFFFUL);
+ }
+ if((ul1 & 0x0000DC00UL) == 0x0000DC00UL) {
+ if(u16l > 1) {
+ if((ul2 & 0x0000DC00UL) == 0x0000D800UL) {
+ ul2 = ((ul2 << 10) & 0x000FFC00UL);
+ ul1 = (ul1 & 0x000003FFUL);
+ result = ul1 | ul2;
+ result = result + 0x00010000UL;
+ *ucp = result; *u16u = 2; back = 1;
+ }
+ }
+ } else {
+ if((ul1 & 0x0000DC00UL) == 0x0000D800UL) {
+ if(u16l > 1) {
+ if((ul2 & 0x0000DC00UL) == 0x0000DC00UL) {
+ ul1 = ((ul1 << 10) & 0x000FFC00UL);
+ ul2 = (ul2 & 0x000003FFUL);
+ result = ul1 | ul2;
+ result = result + 0x00010000UL;
+ *ucp = result; *u16u = 2; back = 1;
+ }
+ }
+ } else {
+ ul1 &= 0x0000FFFFUL;
+ *ucp = ul1; *u16u = 1; back = 1;
+ }
+ }
+ }
+ return back;
+}
+
+
+
+/** Check whether a character is a digit.
+ @param c Character to check.
+ @return 1 on success, 0 on error.
+*/
+static int
+dk3enc_c8_is_digit(char c)
+{
+ int back = 0;
+ switch(c) {
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ {
+ back = 1;
+ }
+ break;
+ }
+ return back;
+}
+
+
+
+/** Convert digit to corresponding unsigned long.
+ @param c Digit.
+ @return Unsigned long for the digit.
+*/
+static
+unsigned long
+dk3enc_c8_to_ul(char c)
+{
+ unsigned long back = 0UL;
+ if(c == '1') back = 1UL;
+ if(c == '2') back = 2UL;
+ if(c == '3') back = 3UL;
+ if(c == '4') back = 4UL;
+ if(c == '5') back = 5UL;
+ if(c == '6') back = 6UL;
+ if(c == '7') back = 7UL;
+ if(c == '8') back = 8UL;
+ if(c == '9') back = 9UL;
+ return back;
+}
+
+
+
+int
+dk3enc_ipaddr_to_ul_app(dkChar const *str, unsigned long *ul, dk3_app_t *app)
+{
+ char bu[512];
+ int back = 0;
+
+
+#line 981 "dk3enc.ctr"
+ if((str) && (ul)) {
+ if(dk3str_string_to_c8_simple_app(bu, sizeof(bu), str, app)) {
+
+#line 983 "dk3enc.ctr"
+ back = dk3enc_c8_ipaddr_to_ul_app(bu, ul, app);
+ } else {
+ /* ERROR: Conversion failed! */
+ }
+ }
+
+#line 988 "dk3enc.ctr"
+ return back;
+}
+
+
+
+int
+dk3enc_c8_ipaddr_to_ul_app(char const *str, unsigned long *ul, dk3_app_t *app)
+{
+ int back = 0;
+ int state = 0; /* Current state. */
+ char const *ptr = NULL; /* Used to traverse string. */
+ unsigned long ul1 = 0UL; /* First part of IP address. */
+ unsigned long ul2 = 0UL; /* Second part of IP address. */
+ unsigned long ul3 = 0UL; /* Third part of IP address. */
+ unsigned long ulval = 0UL; /* Resulting IP address. */
+
+
+#line 1004 "dk3enc.ctr"
+ if(str && ul) {
+ state = 0; ptr = str; back = 1;
+ ul1 = ul2 = ul3 = ulval = 0UL;
+ while(back && (*ptr)) {
+ if(dk3enc_c8_is_digit(*ptr)) {
+ switch(state) {
+ case 0:
+ case 1:
+ case 2:
+ case 4:
+ case 5:
+ case 6:
+ case 8:
+ case 9:
+ case 10:
+ case 12:
+ case 13:
+ case 14: {
+ ulval = 10UL * ulval + dk3enc_c8_to_ul(*ptr); state++;
+ } break;
+ default: {
+ back = 0;
+ } break;
+ }
+ } else {
+ if(*ptr == '.') {
+ switch(state) {
+ case 0:
+ case 1:
+ case 2:
+ case 3: {
+ ul1 = ulval; ulval = 0UL; state = 4;
+ } break;
+ case 4:
+ case 5:
+ case 6:
+ case 7: {
+ ul2 = ulval; ulval = 0UL; state = 8;
+ } break;
+ case 8:
+ case 9:
+ case 10:
+ case 11: {
+ ul3 = ulval; ulval = 0UL; state = 12;
+ } break;
+ }
+ } else {
+ back = 0;
+ }
+ }
+ ptr++;
+ }
+ if((state < 12) || (state > 15)) {
+ back = 0;
+ }
+ if(back) {
+ if(ul1 > 255UL) back = 1;
+ if(ul2 > 255UL) back = 1;
+ if(ul3 > 255UL) back = 1;
+ if(ulval > 255UL) back = 1;
+ }
+ if(back) {
+ ul1 = ul1 << 24;
+ ul1 &= 0xFF000000UL;
+ ul2 = ul2 << 16;
+ ul2 &= 0x00FF0000UL;
+ ul3 = ul3 << 8;
+ ul3 &= 0x0000FF00UL;
+ ulval &= 0x000000FFUL;
+ ulval = ulval | ul1 | ul2 | ul3;
+ *ul = ulval;
+ } else {
+ if(app) {
+ /* Not an IP address! */
+ }
+ }
+ }
+
+
+#line 1082 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_size_bin_to_a85(size_t s)
+{
+#if VERSION_BEFORE_20140809
+ size_t back = 0;
+ int ec = 0; /* Error code. */
+ unsigned long ul1 = 0UL; /* Original size converted to unsigned long. */
+ unsigned long ul2 = 0UL; /* Remainder of division by 4. */
+ unsigned long ul3 = 0UL; /* Result division by 4. */
+
+
+#line 1097 "dk3enc.ctr"
+ ul1 = (unsigned long)s;
+ ul2 = ul1 % 4UL;
+ ul3 = ul1 / 4UL;
+ if(ul2) ul2++; /* for last incomplete block */
+ ul1 = dk3ma_ul_add_ok(
+ dk3ma_ul_mul_ok(ul3, 5UL, &ec),
+ ul2,
+ &ec
+ ); /* add 25 percent */
+ ul1++; /* final 0x00 byte for string */
+ back = (size_t)ul1;
+ if(ec) back = 0; /* error checking */
+ if((unsigned long)back != ul1) back = 0;
+
+
+#line 1111 "dk3enc.ctr"
+ return back;
+#else
+ size_t back = 0;
+ size_t rem = 0; /* Division remainder */
+ size_t res = 0; /* Division result */
+ int ec = 0; /* Error code */
+
+
+#line 1118 "dk3enc.ctr"
+ rem = s % 4;
+ res = s / 4;
+ if (rem) { rem++; }
+ /* back = 5 * res + rem + 1 */
+ rem++;
+ back = dk3mem_add_size_t(rem, dk3mem_mul_size_t(5, res, &ec), &ec);
+ if (ec) { back = 0; }
+
+
+#line 1126 "dk3enc.ctr"
+ return back;
+#endif
+}
+
+
+
+/** Convert binary data to ASCII-85 encoded string.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+*/
+static
+void
+dk3enc_do_bin_to_ra85(char *dp, size_t ds, char const *sp, size_t ss)
+{
+ register char const *mysp = NULL; /* Source pointer. */
+ register unsigned char *mydp = NULL; /* Destination pointer. */
+ register unsigned long v = 0UL; /* Output value. */
+ register size_t i = 0; /* Current byte index. */
+ register short vused = 0; /* Flag: v is used. */
+
+
+#line 1148 "dk3enc.ctr"
+ mydp = (unsigned char *)dp; mysp = sp; v = 0UL; vused = 0;
+ for(i = 0; i < ss; i++) {
+ switch(vused++) {
+ case 3: {
+ v |=
+ ((((unsigned long)((unsigned char)(*(mysp++)))) << 24) & 0xFF000000UL);
+ } break;
+ case 2: {
+ v |=
+ ((((unsigned long)((unsigned char)(*(mysp++)))) << 16) & 0x00FF0000UL);
+ } break;
+ case 1: {
+ v |=
+ ((((unsigned long)((unsigned char)(*(mysp++)))) << 8) & 0x0000FF00UL);
+ } break;
+ default: {
+ v |=
+ ((((unsigned long)((unsigned char)(*(mysp++)))) ) & dk3enc_last_byte);
+ } break;
+ }
+ if(vused >= 4) {
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ v = v / 85UL;
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ v = v / 85UL;
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ v = v / 85UL;
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ v = v / 85UL;
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ vused = 0; v = 0UL;
+ }
+ }
+ if(vused) {
+ vused++;
+ while(vused--) {
+ *(mydp++) = (unsigned char)((v % 85UL) + 33UL);
+ v = v / 85UL;
+ }
+ }
+ *mydp = '\0';
+
+#line 1189 "dk3enc.ctr"
+}
+
+
+
+int
+dk3enc_bin_to_ra85_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ int back = 0;
+ size_t needed_size = 0; /* Destination buffer minimum size. */
+
+
+#line 1201 "dk3enc.ctr"
+ if((dp) && (sp) && (ds) && (ss)) {
+ needed_size = dk3enc_size_bin_to_a85(ss);
+ if(needed_size) {
+ if(ds >= needed_size) {
+ dk3enc_do_bin_to_ra85(dp, ds, sp, ss);
+ back = 1;
+ } else {
+ if(app) {
+ /* Destination buffer too small! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1215 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_size_a85_to_bin(size_t s)
+{
+ size_t back = 0;
+ unsigned long ul1 = 0UL; /* Original size converted to unsigned long. */
+ unsigned long ul2 = 0UL; /* Remainder of division by 5. */
+ unsigned long ul3 = 0UL; /* Result of division by 5. */
+
+
+#line 1228 "dk3enc.ctr"
+ ul1 = (unsigned long)s;
+ ul2 = ul1 % 5UL;
+ ul3 = ul1 / 5UL;
+ ul1 = 4UL * ul3 + ul2;
+ back = (size_t)ul1;
+
+
+#line 1234 "dk3enc.ctr"
+ return back;
+}
+
+
+
+/** Check whether a character is from the ASCII-85 charset.
+ @param c Character to check.
+ @return 1 on success, 0 on error.
+*/
+static
+int
+dk3enc_c8_is_a85(char c)
+{
+ int back = 1;
+ if((int)c < 33) {
+ back = 0;
+ } else {
+ if((int)c > 117) {
+ back = 0;
+ }
+ }
+ return back;
+}
+
+
+
+/** Convert reverse ASCII-85 encoded data to binary data.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+ @param app Application structure for diagnostics, may be NULL.
+ @return Number of binary bytes produced.
+*/
+static
+size_t
+dk3enc_do_ra85_to_bin(char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app)
+{
+ size_t back = 0;
+ unsigned char *mydp = NULL; /* Destination pointer. */
+ char const *mysp = NULL; /* Source pointer. */
+ unsigned long v = 0UL; /* Double-word. */
+ short vused = 0; /* Flag: v is used. */
+ size_t i = 0; /* Index of current source byte. */
+ int reported_illegal_char = 0; /* Flag: Error already reported. */
+
+
+#line 1280 "dk3enc.ctr"
+ mydp = (unsigned char *)dp; mysp = sp; v = 0UL; vused = 0;
+ for(i = 0; i < ss; i++) {
+ if(dk3enc_c8_is_a85(*mysp)) {
+ v += dk3enc_f2[vused++] * ((((unsigned long)((unsigned char)(*mysp))) & dk3enc_last_byte) - 33UL);
+ if(vused >= 5) {
+ *(mydp++) = (unsigned char)(v & dk3enc_last_byte);
+ *(mydp++) = (unsigned char)((v >> 8) & dk3enc_last_byte);
+ *(mydp++) = (unsigned char)((v >> 16) & dk3enc_last_byte);
+ *(mydp++) = (unsigned char)((v >> 24) & dk3enc_last_byte);
+ back += 4;
+ v = 0UL; vused = 0;
+ }
+ } else {
+ if(app) {
+ if(!reported_illegal_char) {
+ reported_illegal_char = 1;
+ /* Illegal character(s) in source string! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 67);
+ }
+ }
+ }
+ mysp++;
+ }
+ if(vused) {
+ vused--;
+ while(vused--) {
+ *(mydp++) = (unsigned char)(v & dk3enc_last_byte);
+ back++;
+ v = v >> 8;
+ }
+ }
+
+#line 1311 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_ra85_to_bin_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ size_t back = 0;
+ size_t needed_size = 0; /* Minimum output buffer size. */
+
+
+#line 1324 "dk3enc.ctr"
+ if((dp) && (sp) && (ds) && (ss)) {
+ needed_size = dk3enc_size_a85_to_bin(ss);
+ if(needed_size) {
+ if(ds >= needed_size) {
+ back = dk3enc_do_ra85_to_bin(dp, ds, sp, ss, app);
+ } else {
+ if(app) {
+ /* Destination buffer too small! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1337 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_ra85string_to_bin_app(
+ char *dp, size_t ds, char const *sp, dk3_app_t *app
+)
+{
+ size_t back = 0;
+
+
+#line 1349 "dk3enc.ctr"
+ if(sp) {
+ back = dk3enc_ra85_to_bin_app(dp, ds, sp, dk3str_c8_len(sp), app);
+ }
+ return back;
+}
+
+
+
+/** Convert binary data to ASCII-85 string.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+*/
+static
+void
+dk3enc_do_bin_to_a85(char *dp, size_t ds, char const *sp, size_t ss)
+{
+ register unsigned char *mydp = NULL; /* Destination pointer. */
+ register unsigned char *mysp = NULL; /* Source pointer. */
+ register unsigned long v = 0UL; /* Double-word. */
+ register short vused = 0; /* Flag: v used. */
+ register short addval = 0; /* Value to add. */
+ register size_t i = 0; /* Index of current source byte. */
+
+
+#line 1374 "dk3enc.ctr"
+ mydp = (unsigned char *)dp;
+ mysp = (unsigned char *)sp;
+ v = 0UL;
+ vused = 0;
+ for(i = 0; i < ss; i++) {
+ switch(vused) {
+ case 3: {
+ v |= ( ((unsigned long)(*(mysp++))) & 0x000000FFUL);
+ } break;
+ case 2: {
+ v |= ((((unsigned long)(*(mysp++))) << 8) & 0x0000FF00UL);
+ } break;
+ case 1: {
+ v |= ((((unsigned long)(*(mysp++))) << 16) & 0x00FF0000UL);
+ } break;
+ default: {
+ v |= ((((unsigned long)(*(mysp++))) << 24) & 0xFF000000UL);
+ } break;
+ }
+ if(++vused >= 4) {
+ vused = 5;
+ while(vused--) {
+ *(mydp++) = (unsigned char)(33UL + v / dk3enc_f2[vused]);
+ v = v % dk3enc_f2[vused];
+ }
+ v = 0UL; vused = 0;
+ }
+ }
+ if(vused) {
+ vused++; addval = 5 - vused;
+ while(vused--) {
+ *(mydp++) = (unsigned char)(33UL + v / dk3enc_f2[vused + addval]);
+ v = v % dk3enc_f2[vused + addval];
+ }
+ }
+ *mydp = '\0';
+
+#line 1410 "dk3enc.ctr"
+}
+
+
+
+int
+dk3enc_bin_to_a85_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ int back = 0;
+ size_t needed_size = 0; /* Minimum output buffer size. */
+
+
+#line 1422 "dk3enc.ctr"
+ if((dp) && (sp) && (ds) && (ss)) {
+ needed_size = dk3enc_size_bin_to_a85(ss);
+ if(needed_size) {
+ if(ds >= needed_size) {
+ dk3enc_do_bin_to_a85(dp, ds, sp, ss);
+ back = 1;
+ } else {
+ if(app) {
+ /* Destination buffer too small! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1436 "dk3enc.ctr"
+ return back;
+}
+
+
+
+/** Convert ASCII-85 encoded data to binary data.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+ @param app Application structure for diagnostics, may be NULL.
+ @return Number of binary bytes produced.
+*/
+static
+size_t
+dk3enc_do_a85_to_bin(char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app)
+{
+ register size_t back = 0;
+ register unsigned char *mydp = NULL; /* Destination pointer. */
+ register unsigned char const *mysp = NULL; /* Source pointer. */
+ register unsigned long v = 0UL; /* Double-word. */
+ register short vused = 0; /* Flag: v used. */
+ register size_t i = 0; /* Current source byte index. */
+ unsigned long u1 = 0UL; /* Temporary value. */
+ unsigned long u2 = 0UL; /* Temporary value. */
+ unsigned long u3 = 0UL; /* Temporary value. */
+ int reported_illegal_character = 0;
+
+
+#line 1464 "dk3enc.ctr"
+ mydp = (unsigned char *)dp; mysp = (unsigned char *)sp;
+ v = 0UL; vused = 0;
+ for(i = 0; i < ss; i++) {
+ if(*mysp) {
+ if(dk3enc_c8_is_a85(*mysp)) {
+ v += dk3enc_f2[4 - vused] *
+ ((((unsigned long)(*mysp)) & 0x000000FFUL) - 33UL);
+ } else {
+ if(!reported_illegal_character) {
+ reported_illegal_character = 1;
+ if(app) {
+ /* Illegal character in source data! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 67);
+ }
+ }
+ }
+ vused++;
+ if(vused >= 5) {
+ *(mydp++) = (unsigned char)((v >> 24) & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)((v >> 16) & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)((v >> 8) & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)( v & 0x000000FFUL); back++;
+ v = 0UL; vused = 0;
+ }
+ }
+ mysp++;
+ }
+ if(vused) {
+ u1 = (v >> 24) & 0x000000FFUL;
+ u2 = (v >> 16) & 0x000000FFUL;
+ u3 = (v >> 8) & 0x000000FFUL;
+ switch(vused) {
+ case 2: {
+ if(v & 0x00FFFFFFUL) {
+ u1++; if(u1 >= 256UL) u1 = 0UL;
+ }
+ *(mydp++) = (unsigned char)(u1 & 0x000000FFUL); back++;
+ } break;
+ case 3: {
+ if(v & 0x0000FFFFUL) {
+ u2++;
+ if(u2 >= 256UL) {
+ u2 = 0UL;
+ u1++; if(u1 >= 256UL) u1 = 0UL;
+ }
+ }
+ *(mydp++) = (unsigned char)(u1 & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)(u2 & 0x000000FFUL); back++;
+ } break;
+ case 4: {
+ if(v & 0x000000FFUL) {
+ u3++;
+ if(u3 >= 256UL) {
+ u3 = 0UL;
+ u2++;
+ if(u2 >= 256UL) {
+ u2 = 0UL;
+ u1++; if(u1 >= 256UL) u1 = 0UL;
+ }
+ }
+ }
+ *(mydp++) = (unsigned char)(u1 & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)(u2 & 0x000000FFUL); back++;
+ *(mydp++) = (unsigned char)(u3 & 0x000000FFUL); back++;
+ } break;
+ }
+ }
+
+#line 1531 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_a85_to_bin_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ size_t back = 0;
+ size_t needed_size = 0; /* Minimum output buffer size. */
+
+
+#line 1544 "dk3enc.ctr"
+ if((dp) && (sp) && (ds) && (ss)) {
+ needed_size = dk3enc_size_a85_to_bin(ss);
+ if(needed_size) {
+ if(ds >= needed_size) {
+ back = dk3enc_do_a85_to_bin(dp, ds, sp, ss, app);
+ } else {
+ if(app) {
+ /* Destination buffer too small! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1557 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_a85string_to_bin_app(char *dp, size_t ds, char const *sp, dk3_app_t *app)
+{
+ size_t back = 0;
+
+
+#line 1567 "dk3enc.ctr"
+ if(sp) {
+ back = dk3enc_a85_to_bin_app(dp, ds, sp, dk3str_c8_len(sp), app);
+ }
+
+#line 1570 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_size_bin_to_hex(size_t s)
+{
+#if VERSION_BEFORE_20140809
+ size_t back = 0;
+ int ec = 0; /* Error code. */
+ unsigned long ul1 = 0UL; /* Temporary value for calculation. */
+
+
+#line 1583 "dk3enc.ctr"
+ ul1 = (unsigned long)s;
+ ul1 = dk3ma_ul_mul_ok(ul1, 2UL, &ec);
+ ul1 = dk3ma_ul_add_ok(ul1, 1UL, &ec);
+ back = (size_t)ul1;
+ if(ec) back = 0;
+ if((unsigned long)back != ul1) back = 0;
+
+
+#line 1590 "dk3enc.ctr"
+ return back;
+#else
+ size_t back = 0;
+ int ec = 0; /* Error code */
+
+
+#line 1595 "dk3enc.ctr"
+ back = dk3mem_add_size_t(1, dk3mem_mul_size_t(2, s, &ec), &ec);
+ if (ec) { back = 0; }
+
+
+#line 1598 "dk3enc.ctr"
+ return back;
+#endif
+}
+
+
+
+size_t
+dk3enc_size_hex_to_bin(size_t s)
+{
+ size_t back;
+
+
+#line 1609 "dk3enc.ctr"
+ back = s / 2;
+ back++;
+
+#line 1611 "dk3enc.ctr"
+ return back;
+}
+
+
+
+/** Get higher half-byte from character.
+ @param c Source character.
+ @return Higher half-byte of \a c.
+*/
+static
+char
+dk3enc_c8_high_nibble_hex(char c)
+{
+ char back;
+ back = dk3enc_hex_digits[ (((unsigned short)c) >> 4) & 0x000FU ];
+ return back;
+}
+
+
+
+/** Get lower half-byte from character.
+ @param c Source character.
+ @return Lower half-byte of \a c.
+*/
+static
+char
+dk3enc_c8_low_nibble_hex(char c)
+{
+ char back;
+ back = dk3enc_hex_digits[ ((unsigned short)c) & 0x000FU ];
+ return back;
+}
+
+
+
+/** Convert binary data to hexadecimal string.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+ @param app Application structure for diagnostics, may be NULL.
+*/
+static
+void
+dk3enc_do_bin_to_hex(char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app)
+{
+ register char *mydp = NULL; /* Destination pointer. */
+ register char const *mysp = NULL; /* Source pointer. */
+ register size_t i = 0; /* Current source byte index. */
+
+
+#line 1661 "dk3enc.ctr"
+ mydp = dp; mysp = sp;
+ for(i = 0; i < ss; i++) {
+ *(mydp++) = dk3enc_c8_high_nibble_hex(*mysp);
+ *(mydp++) = dk3enc_c8_low_nibble_hex(*(mysp++));
+ }
+ *mydp = '\0';
+
+#line 1667 "dk3enc.ctr"
+}
+
+
+
+int
+dk3enc_bin_to_hex_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ int back = 0;
+ size_t needed_bytes = 0; /* Minimum output buffer size. */
+
+
+#line 1679 "dk3enc.ctr"
+ if((dp) && (ds) && (sp) && (ss)) {
+ needed_bytes = dk3enc_size_bin_to_hex(ss);
+ if(needed_bytes) {
+ if(ds >= needed_bytes) {
+ dk3enc_do_bin_to_hex(dp, ds, sp, ss, app); back = 1;
+ } else {
+ if(app) {
+ /* Destination buffer too small1 */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1692 "dk3enc.ctr"
+ return back;
+}
+
+
+
+/** Convert hexadecimal data to binary data.
+ @param dp Destination pointer.
+ @param ds Destination size.
+ @param sp Source pointer.
+ @param ss Source size.
+ @param app Application structure for diagnostics, may be NULL.
+ @return Number of bytes created in destination.
+*/
+static
+size_t
+dk3enc_do_hex_to_bin(char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app)
+{
+ register size_t back = 0;
+ register char const *mysp = NULL; /* Source pointer. */
+ register unsigned char *mydp = NULL; /* Destination pointer. */
+ register unsigned char v = 0x00; /* Current byte to process. */
+ register short int vused = 0; /* Flag: v used. */
+ register size_t i = 0; /* Current source byte index. */
+ int reported_illegal_character = 0; /* Flag: Error already reported. */
+
+
+#line 1717 "dk3enc.ctr"
+ mydp = (unsigned char *)dp;
+ mysp = sp; v = 0x00; vused = 0U;
+ for(i = 0; i < ss; i++) {
+ switch(*mysp) {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ case 'a':
+ case 'A':
+ case 'b':
+ case 'B':
+ case 'c':
+ case 'C':
+ case 'd':
+ case 'D':
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'F':
+ {
+ if(vused) {
+ switch(*mysp) {
+ case '0': { v |= 0x00; } break;
+ case '1': { v |= 0x01; } break;
+ case '2': { v |= 0x02; } break;
+ case '3': { v |= 0x03; } break;
+ case '4': { v |= 0x04; } break;
+ case '5': { v |= 0x05; } break;
+ case '6': { v |= 0x06; } break;
+ case '7': { v |= 0x07; } break;
+ case '8': { v |= 0x08; } break;
+ case '9': { v |= 0x09; } break;
+ case 'a': { v |= 0x0A; } break;
+ case 'A': { v |= 0x0A; } break;
+ case 'b': { v |= 0x0B; } break;
+ case 'B': { v |= 0x0B; } break;
+ case 'c': { v |= 0x0C; } break;
+ case 'C': { v |= 0x0C; } break;
+ case 'd': { v |= 0x0D; } break;
+ case 'D': { v |= 0x0D; } break;
+ case 'e': { v |= 0x0E; } break;
+ case 'E': { v |= 0x0E; } break;
+ case 'f': { v |= 0x0F; } break;
+ case 'F': { v |= 0x0F; } break;
+ }
+ *(mydp++) = v; back++; v = 0; vused = 0U;
+ } else {
+ switch(*mysp) {
+ case '0': { v = 0x00; } break;
+ case '1': { v = 0x10; } break;
+ case '2': { v = 0x20; } break;
+ case '3': { v = 0x30; } break;
+ case '4': { v = 0x40; } break;
+ case '5': { v = 0x50; } break;
+ case '6': { v = 0x60; } break;
+ case '7': { v = 0x70; } break;
+ case '8': { v = 0x80; } break;
+ case '9': { v = 0x90; } break;
+ case 'a': { v = 0xA0; } break;
+ case 'A': { v = 0xA0; } break;
+ case 'b': { v = 0xB0; } break;
+ case 'B': { v = 0xB0; } break;
+ case 'c': { v = 0xC0; } break;
+ case 'C': { v = 0xC0; } break;
+ case 'd': { v = 0xD0; } break;
+ case 'D': { v = 0xD0; } break;
+ case 'e': { v = 0xE0; } break;
+ case 'E': { v = 0xE0; } break;
+ case 'f': { v = 0xF0; } break;
+ case 'F': { v = 0xF0; } break;
+ }
+ vused = 1U;
+ }
+ } break;
+ default: {
+ if(!reported_illegal_character) {
+ reported_illegal_character = 1;
+ if(app) {
+ /* Illegal character(s) in source! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 67);
+ }
+ }
+ } break;
+ }
+ mysp++;
+ }
+ if(vused) {
+ *mydp = v; back++;
+ }
+
+#line 1813 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_hex_to_bin_app(
+ char *dp, size_t ds, char const *sp, size_t ss, dk3_app_t *app
+)
+{
+ size_t back = 0;
+ size_t needed_bytes = 0; /* Minimum output buffer size. */
+
+
+#line 1826 "dk3enc.ctr"
+ if((dp) && (ds) && (sp) && (ss)) {
+ needed_bytes = dk3enc_size_hex_to_bin(ss);
+ if(needed_bytes) {
+ if(ds >= needed_bytes) {
+ back = dk3enc_do_hex_to_bin(dp, ds, sp, ss, app);
+ } else {
+ if(app) {
+ /* Destination buffer too small! */
+ dk3app_log_i1(app, DK3_LL_ERROR, 38);
+ }
+ }
+ }
+ }
+
+#line 1839 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_hexstring_to_bin_app(
+ char *dp, size_t ds, char const *sp, dk3_app_t *app
+)
+{
+ size_t back = 0;
+
+
+#line 1851 "dk3enc.ctr"
+ if(sp) {
+ back = dk3enc_hex_to_bin_app(dp, ds, sp, dk3str_c8_len(sp), app);
+ }
+
+#line 1854 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_size_hexstring_to_bin(char const *s)
+{
+ size_t back = 0;
+
+
+#line 1864 "dk3enc.ctr"
+ if(s) {
+ back = dk3str_c8_len(s);
+ back = dk3enc_size_hex_to_bin(back);
+ }
+
+#line 1868 "dk3enc.ctr"
+ return back;
+}
+
+
+
+size_t
+dk3enc_size_a85string_to_bin(char const *s)
+{
+ size_t back = 0;
+
+
+#line 1878 "dk3enc.ctr"
+ if(s) {
+ back = dk3str_c8_len(s);
+ back = dk3enc_size_a85_to_bin(back);
+ }
+
+#line 1882 "dk3enc.ctr"
+ return back;
+}
+
+
+
+int
+dk3enc_get_type_app(dkChar const *n, dk3_app_t *app)
+{
+ int back = -1;
+ if(n) {
+ back = dk3str_array_index(dk3enc_data_encoding_names, n, 0);
+ if(back >= 0) {
+ switch(back) {
+ case 0: case 3: {
+ back = DK3_DATA_ENCODING_HEX;
+ } break;
+ case 1: case 4: case 6: {
+ back = DK3_DATA_ENCODING_ASCII85;
+ } break;
+ case 2: case 5: case 7: {
+ back = DK3_DATA_ENCODING_REVERSE_ASCII85;
+ } break;
+ }
+ } else {
+ if(app) {
+ dk3app_log_i3(app, DK3_LL_ERROR, 129, 130, n);
+ }
+ }
+ }
+ return back;
+}
+
+
+dkChar const *
+dk3enc_get_data_encoding_name(int t)
+{
+ dkChar const *back = NULL;
+ if((t >= 0) && (t <= 2)) {
+ back = dk3enc_data_encoding_names[t];
+ }
+ return back;
+}
+
+
+
+int
+dk3enc_get_text_encoding_app(dkChar const *en, dk3_app_t *app)
+{
+ int back = -1;
+ int i;
+
+
+#line 1933 "dk3enc.ctr"
+ if(app) { back = dk3app_get_output_encoding(app); }
+ if(en) {
+ i = dk3str_array_index(dk3enc_text_encoding_names, en, 0);
+
+#line 1936 "dk3enc.ctr"
+ switch(i) {
+ case 0: case 8: case 9: {
+ back = DK3_FILE_ENCODING_ASCII;
+ } break;
+ case 1: case 10: {
+ back = DK3_FILE_ENCODING_UTF8;
+ } break;
+ case 2: case 11: {
+#if DK3_HAVE_BIGENDIAN
+ back = DK3_FILE_ENCODING_UTF16_MSB_FIRST;
+#else
+ back = DK3_FILE_ENCODING_UTF16_LSB_FIRST;
+#endif
+ } break;
+ case 3: case 18: case 19: case 20: case 21: case 22: case 23: {
+ back = DK3_FILE_ENCODING_UTF16_MSB_FIRST;
+ } break;
+ case 4: case 12: case 13: case 14: case 15: case 16: case 17: {
+ back = DK3_FILE_ENCODING_UTF16_LSB_FIRST;
+ } break;
+ case 5: case 24: {
+#if DK3_HAVE_BIGENDIAN
+ back = DK3_FILE_ENCODING_UNICODE_MSB_FIRST;
+#else
+ back = DK3_FILE_ENCODING_UNICODE_LSB_FIRST;
+#endif
+ } break;
+ case 6: case 29: case 30: case 31: case 32: {
+ back = DK3_FILE_ENCODING_UNICODE_MSB_FIRST;
+ } break;
+ case 7: case 25: case 26: case 27: case 28: {
+ back = DK3_FILE_ENCODING_UNICODE_LSB_FIRST;
+ } break;
+ default: {
+ if(app) {
+ /* ERROR: Unknown text encoding name! */
+ dk3app_log_i3(app, DK3_LL_ERROR, 129, 130, en);
+ }
+ } break;
+ }
+ }
+
+#line 1977 "dk3enc.ctr"
+ return back;
+}
+
+
+
+int
+dk3enc_get_encoding(dk3_app_t *app)
+{
+ int back = 0;
+#if DK3_CHAR_SIZE == 1
+ char *ptr;
+#endif
+ if(app) {
+ back = dk3app_get_encoding(app);
+ } else {
+#if DK3_CHAR_SIZE > 1
+#if DK3_CHAR_SIZE > 2
+ back = DK3_ENCODING_UNICODE;
+#else
+ back = DK3_ENCODING_UTF16;
+#endif
+#else
+ back = DK3_ENCODING_PLAIN;
+ ptr = getenv("LANG");
+ if(ptr) {
+ ptr = dk3str_c8_chr(ptr, '.');
+ if(ptr) {
+ ptr++;
+ switch(dk3str_c8_array_index(dk3enc_utf8_names, ptr, 0)) {
+ case 0: case 1: {
+ back = DK3_ENCODING_UTF8;
+ } break;
+ }
+ }
+ }
+#endif
+ }
+ return back;
+}
+
+
+
+/* vim: set ai sw=2 : */
+