iodine 0.4.19 → 0.5.0

data/ext/iodine/fiobj_primitives.h

@@ -1,55 +0,0 @@
-#ifndef FIOBJ_PRIMITIVES_H
-/*
-Copyright: Boaz Segev, 2017
-License: MIT
-*/
-
-/**
-Herein are defined some primitive types for the facil.io dynamic object system.
-*/
-#define FIOBJ_PRIMITIVES_H
-
-#include "fiobject.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* *****************************************************************************
-NULL
-***************************************************************************** */
-
-/** Identifies the NULL type. */
-extern const uintptr_t FIOBJ_T_NULL;
-
-/** Returns a NULL object. */
-fiobj_s *fiobj_null(void);
-
-/** Tests if a `fiobj_s *` is NULL. */
-#define FIOBJ_IS_NULL(o) ((o) == NULL) || ((fiobj_s *)(o)->type == FIOBJ_T_NULL)
-
-/* *****************************************************************************
-True
-***************************************************************************** */
-
-/** Identifies the TRUE type. */
-extern const uintptr_t FIOBJ_T_TRUE;
-
-/** Returns a TRUE object. */
-fiobj_s *fiobj_true(void);
-
-/* *****************************************************************************
-False
-***************************************************************************** */
-
-/** Identifies the FALSE type. */
-extern const uintptr_t FIOBJ_T_FALSE;
-
-/** Returns a FALSE object. */
-fiobj_s *fiobj_false(void);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif

data/ext/iodine/fiobj_sym.c

@@ -1,135 +0,0 @@
-/*
-Copyright: Boaz segev, 2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-
-#include "fiobj_internal.h"
-
-/* *****************************************************************************
-Symbol Type
-***************************************************************************** */
-
-typedef struct {
-  struct fiobj_vtable_s *vtable;
-  uintptr_t hash;
-  uint64_t len;
-  char str[];
-} fiobj_sym_s;
-
-#define obj2sym(o) ((fiobj_sym_s *)(o))
-
-/* *****************************************************************************
-Symbol VTable
-***************************************************************************** */
-
-static int fiobj_sym_is_eq(const fiobj_s *self, const fiobj_s *other) {
-  if (other->type != self->type)
-    return 0;
-  return obj2sym(self)->hash == obj2sym(other)->hash;
-}
-
-static fio_cstr_s fio_sym2str(const fiobj_s *o) {
-  return (fio_cstr_s){.buffer = obj2sym(o)->str, .len = obj2sym(o)->len};
-}
-static int64_t fio_sym2i(const fiobj_s *o) {
-  char *s = obj2sym(o)->str;
-  return fio_atol(&s);
-}
-static double fio_sym2f(const fiobj_s *o) {
-  char *s = obj2sym(o)->str;
-  return fio_atof(&s);
-}
-
-static struct fiobj_vtable_s FIOBJ_VTABLE_SYMBOL = {
-    .name = "Symbol",
-    .free = fiobj_simple_dealloc,
-    .to_i = fio_sym2i,
-    .to_f = fio_sym2f,
-    .to_str = fio_sym2str,
-    .is_eq = fiobj_sym_is_eq,
-    .is_true = fiobj_noop_true,
-    .count = fiobj_noop_count,
-    .unwrap = fiobj_noop_unwrap,
-    .each1 = fiobj_noop_each1,
-};
-
-const uintptr_t FIOBJ_T_SYMBOL = (uintptr_t)(&FIOBJ_VTABLE_SYMBOL);
-
-/* *****************************************************************************
-Symbol API
-***************************************************************************** */
-
-static inline fiobj_s *fiobj_sym_alloc(size_t len) {
-  fiobj_s *o = fiobj_alloc(sizeof(fiobj_sym_s) + len + 1);
-  if (!o)
-    perror("ERROR: fiobj symbol couldn't allocate memory"), exit(errno);
-  *obj2sym(o) = (fiobj_sym_s){
-      .vtable = &FIOBJ_VTABLE_SYMBOL, .len = len,
-  };
-  return o;
-}
-
-/** Creates a Symbol object. Use `fiobj_free`. */
-fiobj_s *fiobj_sym_new(const char *str, size_t len) {
-  fiobj_s *s = fiobj_sym_alloc(len);
-  if (str)
-    memcpy(obj2sym(s)->str, str, len);
-  obj2sym(s)->str[len] = 0;
-  obj2sym(s)->hash = (uintptr_t)fiobj_sym_hash(str, len);
-  return s;
-}
-
-/** Finalizes a pre-allocated Symbol buffer to set it's final length and
- * calculate it's final hashing value. */
-fiobj_s *fiobj_sym_reinitialize(fiobj_s *s, const size_t len) {
-  if (obj2sym(s)->len < len)
-    fprintf(stderr,
-            "FATAL ERROR: facil.io Symbol object reinitialization error.\n"),
-        exit(-1);
-  obj2sym(s)->len = len;
-  obj2sym(s)->str[len] = 0;
-  obj2sym(s)->hash = (uintptr_t)fiobj_sym_hash(obj2sym(s)->str, len);
-  return s;
-}
-
-/** Creates a Symbol object using a printf like interface. */
-__attribute__((format(printf, 1, 0))) fiobj_s *
-fiobj_symvprintf(const char *format, va_list argv) {
-  fiobj_s *sym = NULL;
-  va_list argv_cpy;
-  va_copy(argv_cpy, argv);
-  int len = vsnprintf(NULL, 0, format, argv_cpy);
-  va_end(argv_cpy);
-  if (len <= 0) {
-    sym = fiobj_sym_alloc(0);
-    obj2sym(sym)->hash = fiobj_sym_hash(NULL, 0);
-    return sym;
-  }
-  sym = fiobj_sym_alloc(len); /* adds 1 to len, for NUL */
-  vsnprintf(obj2sym(sym)->str, len + 1, format, argv);
-  obj2sym(sym)->str[len] = 0; /* enforce NUL */
-  obj2sym(sym)->hash = (uintptr_t)fiobj_sym_hash(obj2sym(sym)->str, len);
-  return sym;
-}
-__attribute__((format(printf, 1, 2))) fiobj_s *
-fiobj_symprintf(const char *format, ...) {
-  va_list argv;
-  va_start(argv, format);
-  fiobj_s *sym = fiobj_symvprintf(format, argv);
-  va_end(argv);
-  return sym;
-}
-
-/**
- * Returns a symbol's identifier.
- *
- * The unique identifier is calculated using SipHash and is equal for all Symbol
- * objects that were created using the same data.
- */
-uintptr_t fiobj_sym_id(fiobj_s *sym) {
-  if (sym->type != FIOBJ_T_SYMBOL)
-    return 0;
-  return obj2sym(sym)->hash;
-}

data/ext/iodine/fiobj_sym.h

@@ -1,60 +0,0 @@
-#ifndef H_FIOBJ_SYMBOL_H
-/*
-Copyright: Boaz Segev, 2017
-License: MIT
-*/
-
-/**
- */
-#define H_FIOBJ_SYMBOL_H
-
-#include "fiobject.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Symbol type identifier */
-extern const uintptr_t FIOBJ_T_SYMBOL;
-
-/* *****************************************************************************
-Symbol API
-***************************************************************************** */
-
-/** Creates a Symbol object. Use `fiobj_free`. */
-fiobj_s *fiobj_sym_new(const char *str, size_t len);
-
-/** Creates a Symbol object using a printf like interface. */
-__attribute__((format(printf, 1, 0))) fiobj_s *
-fiobj_symvprintf(const char *format, va_list argv);
-
-/** Creates a Symbol object using a printf like interface. */
-__attribute__((format(printf, 1, 2))) fiobj_s *
-fiobj_symprintf(const char *format, ...);
-
-/**
- * Returns a symbol's identifier.
- *
- * The unique identifier is calculated using SipHash and is equal for all Symbol
- * objects that were created using the same data.
- */
-uintptr_t fiobj_sym_id(fiobj_s *sym);
-
-/* *****************************************************************************
-Risky Symbol API
-***************************************************************************** */
-
-/**
- * Reinitializes a pre-allocated Symbol buffer to set it's final length and
- * calculate it's final hashing value.
- *
- * NEVER use this on a symbol that was already used in other objects, such as a
- * Hash.
- */
-fiobj_s *fiobj_sym_reinitialize(fiobj_s *s, const size_t len);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif

data/ext/iodine/hex.c

@@ -1,124 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-#include "hex.h"
-#include <ctype.h>
-
-/* ***************************************************************************
-Hex Conversion
-*/
-
-/*
-#define hex2i(h) \
-  (((h) >= '0' && (h) <= '9') ? ((h) - '0') : (((h) | 32) - 'a' + 10))
-*/
-
-#define i2hex(hi) (((hi) < 10) ? ('0' + (hi)) : ('A' + ((hi)-10)))
-
-/* Credit to Jonathan Leffler for the idea */
-#define hex2i(c)                                                               \
-  (((c) >= '0' && (c) <= '9')                                                  \
-       ? ((c)-48)                                                              \
-       : (((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))            \
-             ? (((c) | 32) - 87)                                               \
-             : ({                                                              \
-                 return -1;                                                    \
-                 0;                                                            \
-               }))
-
-/**
-Returns 1 if the string is HEX encoded (no non-valid hex values). Returns 0 if
-it isn't.
-*/
-int bscrypt_is_hex(const char *string, size_t length) {
-  // for (size_t i = 0; i < length; i++) {
-  //   if (isxdigit(string[i]) == 0)
-  //     return 0;
-  char c;
-  for (size_t i = 0; i < length; i++) {
-    c = string[i];
-    if ((!isspace(c)) &&
-        (c < '0' || c > 'z' ||
-         !((c >= 'a') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))))
-      return 0;
-  }
-  return 1;
-}
-/**
-This will convert the string (byte stream) to a Hex string. This is not
-cryptography, just conversion for pretty print.
-
-The target buffer MUST have enough room for the expected data. The expected
-data is double the length of the string + 1 byte for the NULL terminator
-byte.
-
-A NULL byte will be appended to the target buffer. The function will return
-the number of bytes written to the target buffer.
-
-Returns the number of bytes actually written to the target buffer (excluding
-the NULL terminator byte).
-*/
-int bscrypt_str2hex(char *target, const char *string, size_t length) {
-  if (!target)
-    return -1;
-  size_t i = length;
-  target[(length << 1) + 1] = 0;
-  // go in reverse, so that target could be same as string.
-  while (i) {
-    --i;
-    target[(i << 1) + 1] = i2hex(string[i] & 0x0F);
-    target[(i << 1)] = i2hex(((uint8_t *)string)[i] >> 4);
-  }
-  return (length << 1);
-}
-
-/**
-This will convert a Hex string to a byte string. This is not cryptography,
-just conversion for pretty print.
-
-The target buffer MUST have enough room for the expected data. The expected
-data is half the length of the Hex string + 1 byte for the NULL terminator
-byte.
-
-A NULL byte will be appended to the target buffer. The function will return
-the number of bytes written to the target buffer.
-
-If the target buffer is NULL, the encoded string will be destructively
-edited
-and the decoded data will be placed in the original string's buffer.
-
-Returns the number of bytes actually written to the target buffer (excluding
-the NULL terminator byte).
-*/
-int bscrypt_hex2str(char *target, char *hex, size_t length) {
-  if (!target)
-    target = hex;
-  size_t i = 0;
-  size_t written = 0;
-  while (i + 1 < length) {
-    if (isspace(hex[i])) {
-      ++i;
-      continue;
-    }
-    target[written] = (hex2i(hex[i]) << 4) | hex2i(hex[i + 1]);
-    ++written;
-    i += 2;
-  }
-  if (i < length && !isspace(hex[i])) {
-    target[written] = hex2i(hex[i + 1]);
-    ++written;
-  }
-
-  target[written] = 0;
-  return written;
-}
-
-#undef hex2i
-#undef i2hex

data/ext/iodine/hex.h

@@ -1,70 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef bscrypt_HEX_H
-#define bscrypt_HEX_H
-#include "bscrypt-common.h"
-/* *****************************************************************************
-C++ extern
-*/
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-/* ***************************************************************************
-Hex Conversion
-*/
-
-/**
-Returns 1 if the string is HEX encoded (no non-valid hex values). Returns 0 if
-it isn't.
-*/
-int bscrypt_is_hex(const char *string, size_t length);
-/**
-This will convert the string (byte stream) to a Hex string. This is not
-cryptography, just conversion for pretty print.
-
-The target buffer MUST have enough room for the expected data. The expected
-data is double the length of the string + 1 byte for the NULL terminator
-byte.
-
-A NULL byte will be appended to the target buffer. The function will return
-the number of bytes written to the target buffer.
-
-Returns the number of bytes actually written to the target buffer (excluding
-the NULL terminator byte).
-*/
-int bscrypt_str2hex(char *target, const char *string, size_t length);
-
-/**
-This will convert a Hex string to a byte string. This is not cryptography,
-just conversion for pretty print.
-
-The target buffer MUST have enough room for the expected data. The expected
-data is half the length of the Hex string + 1 byte for the NULL terminator
-byte.
-
-A NULL byte will be appended to the target buffer. The function will return
-the number of bytes written to the target buffer.
-
-If the target buffer is NULL, the encoded string will be destructively
-edited
-and the decoded data will be placed in the original string's buffer.
-
-Returns the number of bytes actually written to the target buffer (excluding
-the NULL terminator byte).
-*/
-int bscrypt_hex2str(char *target, char *hex, size_t length);
-
-/* *****************************************************************************
-C++ extern finish
-*/
-#if defined(__cplusplus)
-}
-#endif
-
-#endif