zemu 0.1.0

data/src/external/Z/API/Z/functions/base/ZRange.h

@@ -0,0 +1,137 @@
+/* Z Kit - functions/base/ZRange.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_ZRange_H_
+#define _Z_functions_base_ZRange_H_
+
+#include <Z/functions/base/constructors.h>
+#include <Z/functions/base/value.h>
+
+
+/* MARK: - Implementation */
+
+
+#define Z_IMPLEMENTATION(Type, type)								\
+												\
+static Z_INLINE											\
+zboolean z_range_##type##_are_equal(ZRange##Type a, ZRange##Type b)				\
+	{return a.index == b.index && a.size == b.size;}					\
+												\
+												\
+static Z_INLINE											\
+zboolean z_range_##type##_contains(ZRange##Type object, ZRange##Type other)			\
+	{											\
+	return	object.index		   <= other.index &&					\
+		object.index + object.size >= other.index + other.size;				\
+	}											\
+												\
+												\
+static Z_INLINE											\
+zboolean z_range_##type##_contains_index(ZRange##Type object, z##type index)			\
+	{return index >= object.index && index < object.index + object.size;}			\
+												\
+												\
+static Z_INLINE											\
+zusize z_range_##type##_end(ZRange##Type object)						\
+	{return object.index + object.size;}							\
+												\
+												\
+static Z_INLINE											\
+ZRange##Type z_range_##type##_from_indices(z##type a, z##type b)				\
+	{return a < b ? z_range_##type(a, b - a) : z_range_##type(b, a - b);}			\
+												\
+												\
+static Z_INLINE											\
+zboolean z_range_##type##_intersect(ZRange##Type a, ZRange##Type b)				\
+	{return a.index < b.index + b.size && b.index < a.index + a.size;}			\
+												\
+												\
+static Z_INLINE											\
+ZRange##Type z_range_##type##_intersection(ZRange##Type a, ZRange##Type b)			\
+	{											\
+	z##type index = (a.index > b.index) ? a.index : b.index,				\
+		end   = z_##type##_minimum(a.index + a.size, b.index + b.size);			\
+												\
+	return end > index ? z_range_##type(index, end - index) : z_range_##type##_zero;	\
+	}											\
+												\
+												\
+static Z_INLINE											\
+void z_range_##type##_swap(ZRange##Type *a, ZRange##Type *b)					\
+	{											\
+	ZRange##Type t = *a;									\
+												\
+	*a = *b; *b = t;									\
+	}											\
+												\
+												\
+static Z_INLINE											\
+ZRange##Type z_range_##type##_union(ZRange##Type a, ZRange##Type b)				\
+	{											\
+	z##type	index = (a.index < b.index) ? a.index : b.index,				\
+		a_end = a.index + a.size,							\
+		b_end = b.index + b.size;							\
+												\
+        return z_range_##type(index, ((a_end > b_end) ? a_end : b_end) - index);		\
+	}											\
+												\
+												\
+static Z_INLINE											\
+zboolean z_range_##type##_is_zero(ZRange##Type object)						\
+	{return object.index == 0 && object.size == 0;}
+
+
+#define z_range_type_are_equal(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _are_equal	)
+#define z_range_type_contains(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _contains	)
+#define z_range_type_contains_index(TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _contains_index)
+#define z_range_type_end(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _end		)
+#define z_range_type_from_indices(  TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _from_indices	)
+#define z_range_type_intersect(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _intersect	)
+#define z_range_type_intersection(  TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _intersection	)
+#define z_range_type_is_zero(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _is_zero	)
+#define z_range_type_swap(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _swap		)
+#define z_range_type_union(	    TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _union		)
+
+
+/* MARK: - Implementation expansions */
+
+
+Z_IMPLEMENTATION(UInt8,  uint8 )
+Z_IMPLEMENTATION(UInt16, uint16)
+Z_IMPLEMENTATION(UInt32, uint32)
+
+#ifdef Z_UINT64
+	Z_IMPLEMENTATION(UInt64, uint64)
+#endif
+
+#ifdef Z_UINT128
+	Z_IMPLEMENTATION(UInt128, uint128)
+#endif
+
+
+/* MARK: - Cleanup */
+
+
+#undef Z_IMPLEMENTATION
+
+
+/* MARK: - Default type definitions */
+
+
+#define z_range_are_equal      z_range_type_are_equal	  (USIZE)
+#define z_range_contains       z_range_type_contains	  (USIZE)
+#define z_range_contains_index z_range_type_contains_index(USIZE)
+#define z_range_end	       z_range_type_end		  (USIZE)
+#define z_range_from_indices   z_range_type_from_indices  (USIZE)
+#define z_range_intersect      z_range_type_intersect	  (USIZE)
+#define z_range_intersection   z_range_type_intersection  (USIZE)
+#define z_range_is_zero	       z_range_type_is_zero	  (USIZE)
+#define z_range_swap	       z_range_type_swap	  (USIZE)
+#define z_range_union	       z_range_type_union	  (USIZE)
+
+
+#endif /* _Z_functions_base_ZRange_H_ */

data/src/external/Z/API/Z/functions/base/all.h

@@ -0,0 +1,16 @@
+/* Z Kit - functions/base/all.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_all_H_
+#define _Z_functions_base_all_H_
+
+#include <Z/functions/base/character.h>
+#include <Z/functions/base/Z2DValue.h>
+#include <Z/functions/base/Z3DValue.h>
+#include <Z/functions/base/ZRange.h>
+
+#endif /* _Z_functions_base_all_H_ */

data/src/external/Z/API/Z/functions/base/casting.hpp

@@ -0,0 +1,37 @@
+/* Z Kit - functions/base/casting.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_casting_HPP_
+#define _Z_functions_base_casting_HPP_
+
+#include <Z/traits/Type.hpp>
+
+#if Z_LANGUAGE_HAS(CPP, RVALUE_REFERENCE)
+
+	namespace Zeta {
+
+
+		template <class T>
+		static Z_CT(CPP14) T &&forwardable(typename Type<T>::remove_reference &what) Z_NO_EXCEPTION
+			{return static_cast<T &&>(what);}
+
+
+		template <class T>
+		static Z_CT(CPP14) T &&forwardable(typename Type<T>::remove_reference &&what) Z_NO_EXCEPTION
+			{return static_cast<T &&>(what);}
+
+
+		template <class T>
+		static Z_CT(CPP14) typename Type<T>::remove_reference &&movable(T &&what) Z_NO_EXCEPTION
+			{return static_cast<typename Type<T>::remove_reference &&>(what);}
+
+
+	}
+
+#endif
+
+#endif // _Z_functions_base_casting_HPP_

data/src/external/Z/API/Z/functions/base/character.h

@@ -0,0 +1,38 @@
+/* Z Kit - functions/base/character.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_character_H_
+#define _Z_functions_base_character_H_
+
+#include <Z/types/base.h>
+#include <Z/macros/character.h>
+
+
+#define Z_IMPLEMENTATION_CHARACTER(export, prefix, type)										 \
+																	 \
+export zboolean prefix##type##_is_alphanumeric		 (z##type character) {return Z_CHARACTER_IS_ALPHANUMERIC	   (character);} \
+export zboolean prefix##type##_is_ascii			 (z##type character) {return Z_CHARACTER_IS_ASCII		   (character);} \
+export zboolean prefix##type##_is_base_2_digit		 (z##type character) {return Z_CHARACTER_IS_BASE_2_DIGIT	   (character);} \
+export zboolean prefix##type##_is_base_8_digit		 (z##type character) {return Z_CHARACTER_IS_BASE_8_DIGIT	   (character);} \
+export zboolean prefix##type##_is_base_10_digit		 (z##type character) {return Z_CHARACTER_IS_BASE_10_DIGIT	   (character);} \
+export zboolean prefix##type##_is_base_16_digit		 (z##type character) {return Z_CHARACTER_IS_BASE_16_DIGIT	   (character);} \
+export zboolean prefix##type##_is_base_16_lowercase_digit(z##type character) {return Z_CHARACTER_IS_BASE_16_LOWERCASE_DIGIT(character);} \
+export zboolean prefix##type##_is_base_16_uppercase_digit(z##type character) {return Z_CHARACTER_IS_BASE_16_UPPERCASE_DIGIT(character);} \
+export zboolean prefix##type##_is_blank			 (z##type character) {return Z_CHARACTER_IS_BLANK		   (character);} \
+export zboolean prefix##type##_is_control		 (z##type character) {return Z_CHARACTER_IS_CONTROL		   (character);} \
+export zboolean prefix##type##_is_graphical		 (z##type character) {return Z_CHARACTER_IS_GRAPHICAL		   (character);} \
+export zboolean prefix##type##_is_lowercase_letter	 (z##type character) {return Z_CHARACTER_IS_LOWERCASE_LETTER	   (character);} \
+export zboolean prefix##type##_is_printable		 (z##type character) {return Z_CHARACTER_IS_PRINTABLE		   (character);} \
+export zboolean prefix##type##_is_uppercase_letter	 (z##type character) {return Z_CHARACTER_IS_UPPERCASE_LETTER	   (character);} \
+export z##type	prefix##type##_lowercase		 (z##type character) {return Z_CHARACTER_UPPERCASE		   (character);} \
+export z##type	prefix##type##_uppercase		 (z##type character) {return Z_CHARACTER_UPPERCASE		   (character);}
+
+
+Z_IMPLEMENTATION_CHARACTER(static Z_INLINE, z_, char)
+
+
+#endif /* _Z_functions_base_character_H_ */

data/src/external/Z/API/Z/functions/base/constructors.h

@@ -0,0 +1,326 @@
+/* Z Kit - functions/base/constructors.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_constructors_H_
+#define _Z_functions_base_constructors_H_
+
+#include <Z/types/base.h>
+
+#if Z_LANGUAGE_HAS(C, COMPOUND_LITERAL)
+
+#	define z_2d_uint8(x, y)		   ((Z2DUInt8	 ){x, y}       )
+#	define z_3d_uint8(x, y, z)	   ((Z3DUInt8	 ){x, y, z}    )
+#	define z_4d_uint8(x, y, z, w)	   ((Z4DUInt8	 ){x, y, z, w} )
+#	define z_range_uint8(index, size)  ((ZRangeUInt8 ){index, size})
+#	define z_2d_sint8(x, y)		   ((Z2DSInt8	 ){x, y}       )
+#	define z_3d_sint8(x, y, z)	   ((Z3DSInt8	 ){x, y, z}    )
+#	define z_4d_sint8(x, y, z, w)	   ((Z4DSInt8	 ){x, y, z, w} )
+#	define z_2d_uint16(x, y)	   ((Z2DUInt16	 ){x, y}       )
+#	define z_3d_uint16(x, y, z)	   ((Z3DUInt16	 ){x, y, z}    )
+#	define z_4d_uint16(x, y, z, w)	   ((Z4DUInt16	 ){x, y, z, w} )
+#	define z_range_uint16(index, size) ((ZRangeUInt16){index, size})
+#	define z_2d_sint16(x, y)	   ((Z2DSInt16	 ){x, y}       )
+#	define z_3d_sint16(x, y, z)	   ((Z3DSInt16	 ){x, y, z}    )
+#	define z_4d_sint16(x, y, z, w)	   ((Z4DSInt16	 ){x, y, z, w} )
+#	define z_2d_uint32(x, y)	   ((Z2DUInt32	 ){x, y}       )
+#	define z_3d_uint32(x, y, z)	   ((Z3DUInt32	 ){x, y, z}    )
+#	define z_4d_uint32(x, y, z, w)	   ((Z4DUInt32	 ){x, y, z, w} )
+#	define z_range_uint32(index, size) ((ZRangeUInt32){index, size})
+#	define z_2d_sint32(x, y)	   ((Z2DSInt32	 ){x, y}       )
+#	define z_3d_sint32(x, y, z)	   ((Z3DSInt32	 ){x, y, z}    )
+#	define z_4d_sint32(x, y, z, w)	   ((Z4DSInt32	 ){x, y, z, w} )
+
+#	ifdef Z_UINT64
+#		define z_2d_uint64(x, y)	   ((Z2DUInt64	 ){x, y}       )
+#		define z_3d_uint64(x, y, z)	   ((Z3DUInt64	 ){x, y, z}    )
+#		define z_4d_uint64(x, y, z, w)	   ((Z4DUInt64	 ){x, y, z, w} )
+#		define z_range_uint64(index, size) ((ZRangeUInt64){index, size})
+#	endif
+
+#	ifdef Z_SINT64
+#		define z_2d_sint64(x, y)       ((Z2DSInt64){x, y}      )
+#		define z_3d_sint64(x, y, z)    ((Z3DSInt64){x, y, z}   )
+#		define z_4d_sint64(x, y, z, w) ((Z4DSInt64){x, y, z, w})
+#	endif
+
+#	ifdef Z_UINT128
+#		define z_2d_uint128(x, y)	    ((Z2DUInt128   ){x, y}	 )
+#		define z_3d_uint128(x, y, z)	    ((Z3DUInt128   ){x, y, z}	 )
+#		define z_4d_uint128(x, y, z, w)	    ((Z4DUInt128   ){x, y, z, w} )
+#		define z_range_uint128(index, size) ((ZRangeUInt128){index, size})
+#	endif
+
+#	ifdef Z_SINT128
+#		define z_2d_sint128(x, y)	((Z2DSInt128){x, y}	 )
+#		define z_3d_sint128(x, y, z)	((Z3DSInt128){x, y, z}	 )
+#		define z_4d_sint128(x, y, z, w) ((Z4DSInt128){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT16
+#		define z_2d_float16(x, y)	((Z2DFloat32){x, y}	 )
+#		define z_3d_float16(x, y, z)	((Z3DFloat32){x, y, z}	 )
+#		define z_4d_float16(x, y, z, w) ((Z4DFloat32){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT32
+#		define z_2d_float32(x, y)	((Z2DFloat32){x, y}	 )
+#		define z_3d_float32(x, y, z)	((Z3DFloat32){x, y, z}	 )
+#		define z_4d_float32(x, y, z, w) ((Z4DFloat32){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT64
+#		define z_2d_float64(x, y)	((Z2DFloat64){x, y}	 )
+#		define z_3d_float64(x, y, z)	((Z3DFloat64){x, y, z}	 )
+#		define z_4d_float64(x, y, z, w) ((Z4DFloat64){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT128
+#		define z_2d_float128(x, y)	 ((Z2DFloat128){x, y}	   )
+#		define z_3d_float128(x, y, z)	 ((Z3DFloat128){x, y, z}   )
+#		define z_4d_float128(x, y, z, w) ((Z4DFloat128){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT80_X87
+#		define z_2d_float80_x87(x, y)	    ((Z2DFloat80_x87){x, y}	 )
+#		define z_3d_float80_x87(x, y, z)    ((Z3DFloat80_x87){x, y, z}	 )
+#		define z_4d_float80_x87(x, y, z, w) ((Z4DFloat80_x87){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT96_X87
+#		define z_2d_float96_x87(x, y)	    ((Z2DFloat96_x87){x, y}	 )
+#		define z_3d_float96_x87(x, y, z)    ((Z3DFloat96_x87){x, y, z}	 )
+#		define z_4d_float96_x87(x, y, z, w) ((Z4DFloat96_x87){x, y, z, w})
+#	endif
+
+#	ifdef Z_FLOAT128_X87
+#		define z_2d_float128_x87(x, y)	     ((Z2DFloat128_x87){x, y}	   )
+#		define z_3d_float128_x87(x, y, z)    ((Z3DFloat128_x87){x, y, z}   )
+#		define z_4d_float128_x87(x, y, z, w) ((Z4DFloat128_x87){x, y, z, w})
+#	endif
+
+#else
+
+#	define Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Type, type)		  \
+									  \
+	static Z_INLINE							  \
+	Z2D##Type z_2d_##type(z##type x, z##type y)			  \
+		{							  \
+		Z2D##Type object;					  \
+									  \
+		object.x = x;						  \
+		object.y = y;						  \
+		return object;						  \
+		}							  \
+									  \
+									  \
+	static Z_INLINE							  \
+	Z3D##Type z_3d_##type(z##type x, z##type y, z##type z)		  \
+		{							  \
+		Z3D##Type object;					  \
+									  \
+		object.x = x;						  \
+		object.y = y;						  \
+		object.z = z;						  \
+		return object;						  \
+		}							  \
+									  \
+									  \
+	static Z_INLINE							  \
+	Z4D##Type z_4d_##type(z##type x, z##type y, z##type z, z##type w) \
+		{							  \
+		Z4D##Type object;					  \
+									  \
+		object.x = x;						  \
+		object.y = y;						  \
+		object.z = z;						  \
+		object.w = w;						  \
+		return object;						  \
+		}
+
+
+#	define Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(Type, type)	 \
+								 \
+	static Z_INLINE						 \
+	ZRange##Type z_range_##type(z##type index, z##type size) \
+		{						 \
+		ZRange##Type object;				 \
+								 \
+		object.index = index;				 \
+		object.size  = size;				 \
+		return object;					 \
+		}
+
+
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (UInt8,  uint8 )
+	Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(UInt8,  uint8 )
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (SInt8,  sint8 )
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (UInt16, uint16)
+	Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(UInt16, uint16)
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (SInt16, sint16)
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (UInt32, uint32)
+	Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(UInt32, uint32)
+	Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (SInt32, sint32)
+
+#	ifdef Z_UINT64
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (UInt64, uint64)
+		Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(UInt64, uint64)
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (SInt64, sint64)
+#	endif
+
+#	ifdef Z_UINT128
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (UInt128, uint128)
+		Z_IMPLEMENTATION_ZRange_CONSTRUCTOR(UInt128, uint128)
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS  (SInt128, sint128)
+#	endif
+
+#	ifdef Z_FLOAT16
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float16, float16)
+#	endif
+
+#	ifdef Z_FLOAT32
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float32, float32)
+#	endif
+
+#	ifdef Z_FLOAT64
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float64, float64)
+#	endif
+
+#	ifdef Z_FLOAT128
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float128, float128)
+#	endif
+
+#	ifdef Z_FLOAT80_X87
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float80_x87, float80_x87)
+#	endif
+
+#	ifdef Z_FLOAT96_X87
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float96_x87, float96_x87)
+#	endif
+
+#	ifdef Z_FLOAT128_X87
+		Z_IMPLEMENTATION_ZND_CONSTRUCTORS(Float128_x87, float128_x87)
+#	endif
+
+#	undef Z_IMPLEMENTATION_ZND_CONSTRUCTORS
+#	undef Z_IMPLEMENTATION_ZRange_CONSTRUCTOR
+
+#endif
+
+#define z_2d_uint8_zero	    z_2d_uint8	  (0, 0)
+#define z_3d_uint8_zero	    z_3d_uint8	  (0, 0, 0)
+#define z_4d_uint8_zero	    z_4d_uint8	  (0, 0, 0, 0)
+#define z_range_uint8_zero  z_range_uint8 (0, 0)
+#define z_2d_sint8_zero     z_2d_sint8	  (0, 0)
+#define z_3d_sint8_zero     z_3d_sint8	  (0, 0, 0)
+#define z_4d_sint8_zero     z_4d_sint8	  (0, 0, 0, 0)
+#define z_2d_uint16_zero    z_2d_uint16	  (0, 0)
+#define z_3d_uint16_zero    z_3d_uint16	  (0, 0, 0)
+#define z_4d_uint16_zero    z_4d_uint16	  (0, 0, 0, 0)
+#define z_range_uint16_zero z_range_uint16(0, 0)
+#define z_2d_sint16_zero    z_2d_sint16	  (0, 0)
+#define z_3d_sint16_zero    z_3d_sint16	  (0, 0, 0)
+#define z_4d_sint16_zero    z_4d_sint16	  (0, 0, 0, 0)
+#define z_2d_uint32_zero    z_2d_uint32	  (0, 0)
+#define z_3d_uint32_zero    z_3d_uint32	  (0, 0, 0)
+#define z_4d_uint32_zero    z_4d_uint32	  (0, 0, 0, 0)
+#define z_range_uint32_zero z_range_uint32(0, 0)
+#define z_2d_sint32_zero    z_2d_sint32	  (0, 0)
+#define z_3d_sint32_zero    z_3d_sint32	  (0, 0, 0)
+#define z_4d_sint32_zero    z_4d_sint32	  (0, 0, 0, 0)
+
+#ifdef Z_UINT64
+#	define z_2d_uint64_zero	   z_2d_uint64	 (0, 0)
+#	define z_3d_uint64_zero	   z_3d_uint64	 (0, 0, 0)
+#	define z_4d_uint64_zero	   z_4d_uint64	 (0, 0, 0, 0)
+#	define z_range_uint64_zero z_range_uint64(0, 0)
+#endif
+
+#ifdef Z_SINT64
+#	define z_2d_sint64_zero z_2d_sint64(0, 0)
+#	define z_3d_sint64_zero z_3d_sint64(0, 0, 0)
+#	define z_4d_sint64_zero z_4d_sint64(0, 0, 0, 0)
+#endif
+
+#ifdef Z_UINT128
+#	define z_2d_uint128_zero    z_2d_uint128   (0, 0)
+#	define z_3d_uint128_zero    z_3d_uint128   (0, 0, 0)
+#	define z_4d_uint128_zero    z_4d_uint128   (0, 0, 0, 0)
+#	define z_range_uint128_zero z_range_uint128(0, 0)
+#endif
+
+#ifdef Z_SINT128
+#	define z_2d_sint128_zero z_2d_sint128(0, 0)
+#	define z_3d_sint128_zero z_3d_sint128(0, 0, 0)
+#	define z_4d_sint128_zero z_4d_sint128(0, 0, 0, 0)
+#endif
+
+#ifdef Z_FLOAT16
+#	define z_2d_float16_zero z_2d_float16(0.0, 0.0)
+#	define z_3d_float16_zero z_3d_float16(0.0, 0.0, 0.0)
+#	define z_4d_float16_zero z_4d_float16(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT32
+#	define z_2d_float32_zero z_2d_float32(0.0, 0.0)
+#	define z_3d_float32_zero z_3d_float32(0.0, 0.0, 0.0)
+#	define z_4d_float32_zero z_4d_float32(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT64
+#	define z_2d_float64_zero z_2d_float64(0.0, 0.0)
+#	define z_3d_float64_zero z_3d_float64(0.0, 0.0, 0.0)
+#	define z_4d_float64_zero z_4d_float64(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT128
+#	define z_2d_float128_zero z_2d_float128(0.0, 0.0)
+#	define z_3d_float128_zero z_3d_float128(0.0, 0.0, 0.0)
+#	define z_4d_float128_zero z_4d_float128(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT80_X87
+#	define z_2d_float80_x87_zero z_2d_float80_x87(0.0, 0.0)
+#	define z_3d_float80_x87_zero z_3d_float80_x87(0.0, 0.0, 0.0)
+#	define z_4d_float80_x87_zero z_4d_float80_x87(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT96_X87
+#	define z_2d_float96_x87_zero z_2d_float96_x87(0.0, 0.0)
+#	define z_3d_float96_x87_zero z_3d_float96_x87(0.0, 0.0, 0.0)
+#	define z_4d_float96_x87_zero z_4d_float96_x87(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#ifdef Z_FLOAT128_X87
+#	define z_2d_float128_x87_zero z_2d_float128_x87(0.0, 0.0)
+#	define z_3d_float128_x87_zero z_3d_float128_x87(0.0, 0.0, 0.0)
+#	define z_4d_float128_x87_zero z_4d_float128_x87(0.0, 0.0, 0.0, 0.0)
+#endif
+
+#define z_2d_type(	  TYPE) Z_APPEND_##TYPE##_fixed_type(z_2d_   )
+#define z_3d_type(	  TYPE) Z_APPEND_##TYPE##_fixed_type(z_3d_   )
+#define z_4d_type(	  TYPE) Z_APPEND_##TYPE##_fixed_type(z_4d_   )
+#define z_range_type(	  TYPE) Z_APPEND_##TYPE##_fixed_type(z_range_)
+#define z_2d_type_zero(	  TYPE) Z_INSERT_##TYPE##_fixed_type(z_2d_,    _zero)
+#define z_3d_type_zero(	  TYPE) Z_INSERT_##TYPE##_fixed_type(z_3d_,    _zero)
+#define z_4d_type_zero(	  TYPE) Z_INSERT_##TYPE##_fixed_type(z_4d_,    _zero)
+#define z_range_type_zero(TYPE) Z_INSERT_##TYPE##_fixed_type(z_range_, _zero)
+
+/* MARK: - Default real type definitions */
+
+#ifdef Z_REAL
+#	define z_2d	 z_2d_type     (REAL)
+#	define z_3d	 z_3d_type     (REAL)
+#	define z_4d	 z_4d_type     (REAL)
+#	define z_2d_zero z_2d_type_zero(REAL)
+#	define z_3d_zero z_3d_type_zero(REAL)
+#	define z_4d_zero z_4d_type_zero(REAL)
+#endif
+
+#define z_range	     z_range_type     (USIZE)
+#define z_range_zero z_range_type_zero(USIZE)
+
+#endif /* _Z_functions_base_constructors_H_ */

data/src/external/Z/API/Z/functions/base/structure.hpp

@@ -0,0 +1,26 @@
+/* Z Kit - functions/base/structure.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_structure_HPP_
+#define _Z_functions_base_structure_HPP_
+
+#include <Z/types/base.hpp>
+
+namespace Zeta {
+
+
+	template <class T, class C>
+	static Z_CT(CPP11) USize offset_of(T C::*member)
+		{
+		return	(&reinterpret_cast<const UInt8 &>(reinterpret_cast<const C *>(1)->*member) -
+			  reinterpret_cast<const UInt8 *>(1));
+		}
+
+
+}
+
+#endif // _Z_functions_base_structure_HPP_

data/src/external/Z/API/Z/functions/base/type.hpp

@@ -0,0 +1,60 @@
+/* Z Kit - functions/base/type.hpp
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_functions_base_type_HPP_
+#define _Z_functions_base_type_HPP_
+
+#include <Z/classes/base/SizedString.hpp>
+
+#if Z_COMPILER_HAS_MAGIC_CONSTANT(MANGLED_FUNCTION_NAME)
+
+	namespace Zeta {
+
+#		if	Z_COMPILER == Z_COMPILER_GCC   || \
+			Z_COMPILER == Z_COMPILER_CLANG || \
+			Z_COMPILER == Z_COMPILER_APPLE_LLVM
+
+
+			template <class T>
+			static Z_CT(CPP14) USize type_string_size()
+				{
+				const Char *input = __PRETTY_FUNCTION__;
+				USize size = 0;
+				USize bracket_count = 0;
+
+				while (*input++ != '=');
+				while (*++input != ']' || bracket_count)
+					{
+					if	(*input == '[') bracket_count++;
+					else if (*input == ']') bracket_count--;
+
+					size++;
+					}
+
+				return size;
+				}
+
+
+			template <class T, USize S = type_string_size<T>()>
+			static Z_CT(CPP14) SizedString<S> type_string()
+				{
+				const Char *input = __PRETTY_FUNCTION__;
+
+				while (*input++ != '=');
+				return SizedString<S>(input + 1);
+				}
+
+
+#		elif Z_COMPILER == Z_COMPILER_VISUAL_CPP
+
+#		endif
+
+	}
+
+#endif
+
+#endif // _Z_functions_base_type_HPP_