aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorDavid Robillard <d@drobilla.net>2021-04-15 18:34:17 -0400
committerDavid Robillard <d@drobilla.net>2022-01-13 23:03:41 -0500
commitc90c662f85ca1a36794a0404b2101a72de020ca3 (patch)
tree9e4e8abb5a70e955f0236aa9ebeccdbcba02c33f /src
parentf074a83f20e04e360704a190ab5f4e646f4272b7 (diff)
downloadserd-c90c662f85ca1a36794a0404b2101a72de020ca3.tar.gz
serd-c90c662f85ca1a36794a0404b2101a72de020ca3.tar.bz2
serd-c90c662f85ca1a36794a0404b2101a72de020ca3.zip
Use exess for reading and writing numeric and binary literals
Diffstat (limited to 'src')
-rw-r--r--src/base64.c114
-rw-r--r--src/node.c188
-rw-r--r--src/string.c67
-rw-r--r--src/string_utils.h6
4 files changed, 97 insertions, 278 deletions
diff --git a/src/base64.c b/src/base64.c
index 0d79fd88..9dac9979 100644
--- a/src/base64.c
+++ b/src/base64.c
@@ -14,115 +14,25 @@
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include "base64.h"
-
-#include "serd_internal.h"
-#include "string_utils.h"
-
+#include "exess/exess.h"
#include "serd/serd.h"
-#include <stdbool.h>
-#include <stdint.h>
#include <stdlib.h>
-#include <string.h>
-
-/**
- Base64 encoding table.
-
- @see <a href="http://tools.ietf.org/html/rfc3548#section-3">RFC3548 S3</a>.
-*/
-static const uint8_t b64_map[] =
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/**
- Base64 decoding table.
-
- This is indexed by encoded characters and returns the numeric value used
- for decoding, shifted up by 47 to be in the range of printable ASCII.
- A '$' is a placeholder for characters not in the base64 alphabet.
-*/
-static const char b64_unmap[] =
- "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$m$$$ncdefghijkl$$$$$$"
- "$/0123456789:;<=>?@ABCDEFGH$$$$$$IJKLMNOPQRSTUVWXYZ[\\]^_`ab$$$$"
- "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$"
- "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$";
-
-/** Encode 3 raw bytes to 4 base64 characters. */
-static void
-encode_chunk(uint8_t out[4], const uint8_t in[3], const size_t n_in)
-{
- out[0] = b64_map[in[0] >> 2];
- out[1] = b64_map[((in[0] & 0x03) << 4) | ((in[1] & 0xF0) >> 4)];
-
- out[2] = (n_in > 1) ? (b64_map[((in[1] & 0x0F) << 2) | ((in[2] & 0xC0) >> 6)])
- : (uint8_t)'=';
-
- out[3] = ((n_in > 2) ? b64_map[in[2] & 0x3F] : (uint8_t)'=');
-}
-
-size_t
-serd_base64_get_length(const size_t size, const bool wrap_lines)
-{
- return (size + 2) / 3 * 4 + (wrap_lines * ((size - 1) / 57));
-}
-
-bool
-serd_base64_encode(uint8_t* const str,
- const void* const buf,
- const size_t size,
- const bool wrap_lines)
-{
- bool has_newline = false;
- for (size_t i = 0, j = 0; i < size; i += 3, j += 4) {
- uint8_t in[4] = {0, 0, 0, 0};
- size_t n_in = MIN(3, size - i);
- memcpy(in, (const uint8_t*)buf + i, n_in);
-
- if (wrap_lines && i > 0 && (i % 57) == 0) {
- str[j++] = '\n';
- has_newline = true;
- }
-
- encode_chunk(str + j, in, n_in);
- }
-
- return has_newline;
-}
-
-static uint8_t
-unmap(const uint8_t in)
-{
- return (uint8_t)(b64_unmap[in] - 47);
-}
-
-/** Decode 4 base64 characters to 3 raw bytes. */
-static size_t
-decode_chunk(const uint8_t in[4], uint8_t out[3])
-{
- out[0] = (uint8_t)(((unmap(in[0]) << 2)) | unmap(in[1]) >> 4);
- out[1] = (uint8_t)(((unmap(in[1]) << 4) & 0xF0) | unmap(in[2]) >> 2);
- out[2] = (uint8_t)(((unmap(in[2]) << 6) & 0xC0) | unmap(in[3]));
- return 1 + (in[2] != '=') + ((in[2] != '=') && (in[3] != '='));
-}
void*
serd_base64_decode(const char* const str, const size_t len, size_t* const size)
{
- const uint8_t* const ustr = (const uint8_t*)str;
-
- void* buf = malloc((len * 3) / 4 + 2);
- *size = 0;
- for (size_t i = 0, j = 0; i < len; j += 3) {
- uint8_t in[] = "====";
- size_t n_in = 0;
- for (; i < len && n_in < 4; ++n_in) {
- for (; i < len && !is_base64(ustr[i]); ++i) {
- } // Skip junk
- in[n_in] = ustr[i++];
- }
- if (n_in > 1) {
- *size += decode_chunk(in, (uint8_t*)buf + j);
- }
+ const size_t max_size = exess_base64_decoded_size(len);
+
+ void* const buf = malloc(max_size);
+ const ExessVariableResult r = exess_read_base64(max_size, buf, str);
+ if (r.status) {
+ *size = 0;
+ free(buf);
+ return NULL;
}
+
+ *size = r.write_count;
+
return buf;
}
diff --git a/src/node.c b/src/node.c
index cf5f7e46..6ba00048 100644
--- a/src/node.c
+++ b/src/node.c
@@ -1,5 +1,5 @@
/*
- Copyright 2011-2020 David Robillard <d@drobilla.net>
+ Copyright 2011-2021 David Robillard <d@drobilla.net>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
@@ -16,31 +16,25 @@
#include "node.h"
-#include "base64.h"
#include "serd_internal.h"
#include "static_nodes.h"
#include "string_utils.h"
#include "system.h"
+#include "exess/exess.h"
#include "serd/serd.h"
#include <assert.h>
-#include <float.h>
-#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#ifdef _WIN32
-# ifndef isnan
-# define isnan(x) _isnan(x)
-# endif
-# ifndef isinf
-# define isinf(x) (!_finite(x))
-# endif
-#endif
+typedef struct {
+ const void* SERD_NULLABLE buf;
+ size_t len;
+} SerdConstBuffer;
static const SerdNodeFlags meta_mask = (SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE);
@@ -490,138 +484,112 @@ serd_new_file_uri(const SerdStringView path, const SerdStringView hostname)
return node;
}
-static unsigned
-serd_digits(const double abs)
-{
- const double lg = ceil(log10(floor(abs) + 1.0));
- return lg < 1.0 ? 1U : (unsigned)lg;
-}
+typedef size_t (*SerdWriteLiteralFunc)(const void* user_data,
+ size_t buf_size,
+ char* buf);
-SerdNode*
-serd_new_decimal(const double d,
- const unsigned frac_digits,
- const SerdNode* const datatype)
+static SerdNode*
+serd_new_custom_literal(const void* const user_data,
+ const size_t len,
+ const SerdWriteLiteralFunc write,
+ const SerdNode* const datatype)
{
- if (isnan(d) || isinf(d)) {
+ if (len == 0 || !write) {
return NULL;
}
- const SerdNode* type = datatype ? datatype : &serd_xsd_decimal.node;
- const double abs_d = fabs(d);
- const unsigned int_digits = serd_digits(abs_d);
- const size_t len = int_digits + frac_digits + 3;
- const size_t type_len = serd_node_total_size(type);
- const size_t total_len = len + type_len;
-
- SerdNode* const node =
- serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
-
- // Point s to decimal point location
- char* const buf = serd_node_buffer(node);
- const double int_part = floor(abs_d);
- char* s = buf + int_digits;
- if (d < 0.0) {
- *buf = '-';
- ++s;
- }
+ const size_t datatype_size = serd_node_total_size(datatype);
+ const size_t total_size = serd_node_pad_size(len + 1) + datatype_size;
- // Write integer part (right to left)
- char* t = s - 1;
- uint64_t dec = (uint64_t)int_part;
- do {
- *t-- = (char)('0' + dec % 10);
- } while ((dec /= 10) > 0);
-
- *s++ = '.';
-
- // Write fractional part (right to left)
- double frac_part = fabs(d - int_part);
- if (frac_part < DBL_EPSILON) {
- *s++ = '0';
- node->length = (size_t)(s - buf);
- } else {
- uint64_t frac = (uint64_t)llround(frac_part * pow(10.0, (int)frac_digits));
- s += frac_digits - 1;
- unsigned i = 0;
-
- // Skip trailing zeros
- for (; i < frac_digits - 1 && !(frac % 10); ++i, --s, frac /= 10) {
- }
+ SerdNode* const node = serd_node_malloc(
+ total_size, datatype ? SERD_HAS_DATATYPE : 0u, SERD_LITERAL);
- node->length = (size_t)(s - buf) + 1u;
+ node->length = write(user_data, len + 1, serd_node_buffer(node));
- // Write digits from last trailing zero to decimal point
- for (; i < frac_digits; ++i) {
- *s-- = (char)('0' + (frac % 10));
- frac /= 10;
- }
+ if (datatype) {
+ memcpy(serd_node_meta(node), datatype, datatype_size);
}
- memcpy(serd_node_meta(node), type, type_len);
serd_node_check_padding(node);
return node;
}
SerdNode*
-serd_new_integer(const int64_t i, const SerdNode* const datatype)
+serd_new_decimal(const double d, const SerdNode* const datatype)
{
- const SerdNode* type = datatype ? datatype : &serd_xsd_integer.node;
- uint64_t abs_i = (uint64_t)((i < 0) ? -i : i);
- const unsigned digits = serd_digits((double)abs_i);
- const size_t type_len = serd_node_total_size(type);
- const size_t total_len = digits + 2 + type_len;
-
- SerdNode* node = serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
-
- // Point s to the end
- char* buf = serd_node_buffer(node);
- char* s = buf + digits - 1;
- if (i < 0) {
- *buf = '-';
- ++s;
- }
+ // Use given datatype, or xsd:decimal as a default if it is null
+ const SerdNode* type = datatype ? datatype : &serd_xsd_decimal.node;
+ const size_t type_size = serd_node_total_size(type);
+
+ // Measure integer string to know how much space the node will need
+ ExessResult r = exess_write_decimal(d, 0, NULL);
+ assert(!r.status);
- node->length = (size_t)(s - buf) + 1u;
+ // Allocate node with enough space for value and datatype URI
+ SerdNode* const node =
+ serd_node_malloc(serd_node_pad_size(r.count + 1) + type_size,
+ SERD_HAS_DATATYPE,
+ SERD_LITERAL);
- // Write integer part (right to left)
- do {
- *s-- = (char)('0' + (abs_i % 10));
- } while ((abs_i /= 10) > 0);
+ // Write string directly into node
+ r = exess_write_decimal(d, r.count + 1, serd_node_buffer(node));
+ assert(!r.status);
- memcpy(serd_node_meta(node), type, type_len);
+ node->length = r.count;
+ memcpy(serd_node_meta(node), type, type_size);
serd_node_check_padding(node);
return node;
}
SerdNode*
-serd_new_blob(const void* const buf,
- const size_t size,
- const bool wrap_lines,
- const SerdNode* const datatype)
+serd_new_integer(const int64_t i, const SerdNode* const datatype)
{
- if (!buf || !size) {
- return NULL;
- }
+ // Use given datatype, or xsd:integer as a default if it is null
+ const SerdNode* type = datatype ? datatype : &serd_xsd_integer.node;
+ const size_t type_size = serd_node_total_size(type);
- const SerdNode* type = datatype ? datatype : &serd_xsd_base64Binary.node;
- const size_t len = serd_base64_get_length(size, wrap_lines);
- const size_t type_len = serd_node_total_size(type);
- const size_t total_len = len + 1 + type_len;
+ // Measure integer string to know how much space the node will need
+ ExessResult r = exess_write_long(i, 0, NULL);
+ assert(!r.status);
+ // Allocate node with enough space for value and datatype URI
SerdNode* const node =
- serd_node_malloc(total_len, SERD_HAS_DATATYPE, SERD_LITERAL);
+ serd_node_malloc(serd_node_pad_size(r.count + 1) + type_size,
+ SERD_HAS_DATATYPE,
+ SERD_LITERAL);
- uint8_t* str = (uint8_t*)serd_node_buffer(node);
- if (serd_base64_encode(str, buf, size, wrap_lines)) {
- node->flags |= SERD_HAS_NEWLINE;
- }
+ // Write string directly into node
+ r = exess_write_long(i, r.count + 1, serd_node_buffer(node));
+ assert(!r.status);
- node->length = len;
- memcpy(serd_node_meta(node), type, type_len);
+ node->length = r.count;
+ memcpy(serd_node_meta(node), type, type_size);
serd_node_check_padding(node);
return node;
}
+static size_t
+write_base64_literal(const void* const user_data,
+ const size_t buf_size,
+ char* const buf)
+{
+ const SerdConstBuffer blob = *(const SerdConstBuffer*)user_data;
+
+ const ExessResult r = exess_write_base64(blob.len, blob.buf, buf_size, buf);
+
+ return r.status ? 0 : r.count;
+}
+
+SerdNode*
+serd_new_base64(const void* buf, size_t size, const SerdNode* datatype)
+{
+ const size_t len = exess_write_base64(size, buf, 0, NULL).count;
+ const SerdNode* type = datatype ? datatype : &serd_xsd_base64Binary.node;
+ SerdConstBuffer blob = {buf, size};
+
+ return serd_new_custom_literal(&blob, len, write_base64_literal, type);
+}
+
SerdNodeType
serd_node_type(const SerdNode* const node)
{
diff --git a/src/string.c b/src/string.c
index 3a750c4f..c5b1d6f7 100644
--- a/src/string.c
+++ b/src/string.c
@@ -16,6 +16,7 @@
#include "string_utils.h"
+#include "exess/exess.h"
#include "serd/serd.h"
#include <assert.h>
@@ -105,68 +106,14 @@ serd_strlen(const char* const str, SerdNodeFlags* const flags)
return strlen(str);
}
-static double
-read_sign(const char** const sptr)
-{
- double sign = 1.0;
-
- switch (**sptr) {
- case '-':
- sign = -1.0;
- ++(*sptr);
- break;
- case '+':
- ++(*sptr);
- break;
- default:
- break;
- }
-
- return sign;
-}
-
double
-serd_strtod(const char* const str, char** const endptr)
+serd_strtod(const char* const str, const char** const end)
{
- double result = 0.0;
-
- // Point s at the first non-whitespace character
- const char* s = str;
- while (is_space(*s)) {
- ++s;
- }
-
- // Read leading sign if necessary
- const double sign = read_sign(&s);
-
- // Parse integer part
- for (; is_digit(*s); ++s) {
- result = (result * 10.0) + (*s - '0');
- }
-
- // Parse fractional part
- if (*s == '.') {
- double denom = 10.0;
- for (++s; is_digit(*s); ++s) {
- result += (*s - '0') / denom;
- denom *= 10.0;
- }
- }
-
- // Parse exponent
- if (*s == 'e' || *s == 'E') {
- ++s;
- double expt = 0.0;
- double expt_sign = read_sign(&s);
- for (; is_digit(*s); ++s) {
- expt = (expt * 10.0) + (*s - '0');
- }
- result *= pow(10, expt * expt_sign);
- }
-
- if (endptr) {
- *endptr = (char*)s;
+ double value = (double)NAN;
+ const ExessResult r = exess_read_double(&value, str);
+ if (end) {
+ *end = str + r.count;
}
- return result * sign;
+ return r.status ? (double)NAN : value;
}
diff --git a/src/string_utils.h b/src/string_utils.h
index 0e9eee43..07941325 100644
--- a/src/string_utils.h
+++ b/src/string_utils.h
@@ -84,12 +84,6 @@ is_print(const int c)
}
static inline bool
-is_base64(const int c)
-{
- return is_alpha(c) || is_digit(c) || c == '+' || c == '/' || c == '=';
-}
-
-static inline bool
is_windows_path(const char* path)
{
return is_alpha(path[0]) && (path[1] == ':' || path[1] == '|') &&