Leahnaya/Flips
1
0
Fork 0
mirror of https://github.com/Alcaro/Flips.git synced 2026-09-07 10:06:09 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update Arlib

Browse Source
This commit is contained in:
Alcaro
2016-12-23 21:03:12 +01:00
parent c74fa6cd54
commit 63c7cb74cf
9 changed files with 145 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
arlib/Makefile
View File

@@ -227,7 +227,7 @@ ifeq ($(ARSOCKET),1)
endif
endif
SOURCES_ARLIB += arlib/deps/miniz.c
SOURCES_NOWARN += arlib/deps/miniz.c
TRUE_CFLAGS = -std=c99 $(CCXXFLAGS) $(CFLAGS) $(CONF_CFLAGS)
TRUE_CXXFLAGS =-std=c++11 -fno-rtti $(CCXXFLAGS) $(CXXFLAGS) $(CONF_CXXFLAGS)

2
arlib/arlib.h
View File

@@ -17,9 +17,9 @@
#include "endian.h"
#include "file.h"
#include "function.h"
#include "intsafe.h"
#include "intwrap.h"
#include "os.h"
#include "safeint.h"
#include "serialize.h"
#include "string.h"
#include "stringconv.h"

61
arlib/array.h
View File

@@ -2,8 +2,7 @@
#include "global.h"
#include <new>
#include <string.h>
//as much fun as it is to optimize the hell out of random stuff, I want to get things done as well
#include <type_traits>
//size: two pointers
//this object does not own its storage, it's just a pointer wrapper
@@ -149,11 +148,34 @@ template<typename T> class array : public arrayvieww<T> {
//T * items;
//size_t count;
//My requirements:
//- all fields initialized by the default constructor are initialized to 0
//- all copy/move constructors are equivalent to memcpy()
//- there is no destructor
//I believe that is equivalent to (possibly slightly looser than) std::is_trivial.
//If true, constructor calls are replaced with memset. (Destructor is still called; it'll get optimized out anyways.)
static const bool trivial_cons = std::is_trivial<T>::value;
#if __GNUC__ >= 5
static const bool trivial_copy = std::is_trivially_copyable<T>::value;
#else
static const bool trivial_copy = trivial_cons;
#endif
void clone(const arrayview<T>& other)
{
this->count = other.size(); // I can somehow not access non-this instances of my base class, so let's just use the public interface.
this->count = other.size(); // I can't access non-this instances of my base class, so let's just use the public interface.
this->items = malloc(sizeof(T)*bitround(this->count));
for (size_t i=0;i<this->count;i++) new(&this->items[i]) T(other.ptr()[i]);
if (trivial_copy)
{
memcpy(this->items, other.ptr(), sizeof(T)*this->count);
}
else
{
for (size_t i=0;i<this->count;i++)
{
new(&this->items[i]) T(other.ptr()[i]);
}
}
}
void swap(array<T>& other)
@@ -186,11 +208,19 @@ template<typename T> class array : public arrayvieww<T> {
void resize_grow(size_t count)
{
if (this->count >= count) return;
size_t prevcount = this->count;
resize_grow_noinit(count);
for (size_t i=prevcount;i<count;i++)
if (trivial_cons)
{
new(&this->items[i]) T();
memset(this->items+prevcount, 0, sizeof(T)*(count-prevcount));
}
else
{
for (size_t i=prevcount;i<count;i++)
{
new(&this->items[i]) T();
}
}
}
@@ -217,6 +247,11 @@ public:
T& operator[](size_t n) { resize_grow(n+1); return this->items[n]; }
void resize(size_t len) { resize_to(len); }
void resize_noinit(size_t len)
{
if (trivial_cons && len > this->size()) resize_grow_noinit(len);
else resize_to(len);
}
void reserve(size_t len) { resize_grow(len); }
void append(const T& item) { size_t pos = this->count; resize_grow(pos+1); this->items[pos] = item; }
@@ -302,14 +337,22 @@ public:
array<T>& operator+=(arrayview<T> other)
{
//TODO: x+=x doesn't work
size_t prevcount = this->count;
size_t othercount = other.size(); // in case this==other
size_t othercount = other.size();
resize_grow_noinit(prevcount + othercount);
for (size_t i=0;i<othercount;i++)
if (trivial_copy)
{
new(&this->items[prevcount + i]) T(other[i]);
memcpy(this->items+prevcount, other.ptr(), sizeof(T)*othercount);
}
else
{
for (size_t i=0;i<othercount;i++)
{
new(&this->items[prevcount + i]) T(other[i]);
}
}
return *this;

56
arlib/crc32.cpp
View File

@@ -1,8 +1,38 @@
#include "crc32.h"
static const uint32_t crctable_4bits[]={
0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C,
0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C, 0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C,
static const uint32_t crctable[256]={
0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3,
0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,
0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7,
0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5,
0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,
0x35B5A8FA,0x42B2986C,0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,
0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F,
0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D,
0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433,
0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,0x91646C97,0xE6635C01,
0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,
0x65B0D9C6,0x12B7E950,0x8BBEB8EA,0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,
0x4DB26158,0x3AB551CE,0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB,
0x4369E96A,0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,
0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,0xCE61E49F,
0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,0xB7BD5C3B,0xC0BA6CAD,
0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,0x9DD277AF,0x04DB2615,0x73DC1683,
0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,
0xF00F9344,0x8708A3D2,0x1E01F268,0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7,
0xFED41B76,0x89D32BE0,0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,
0xD6D6A3E8,0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,
0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,0x4669BE79,
0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,0x220216B9,0x5505262F,
0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,
0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,0x9C0906A9,0xEB0E363F,0x72076785,0x05005713,
0x95BF4A82,0xE2B87A14,0x7BB12BAE,0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,
0x86D3D2D4,0xF1D4E242,0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,
0x88085AE6,0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45,
0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,0x3E6E77DB,
0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,0x47B2CF7F,0x30B5FFE9,
0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,0xCDD70693,0x54DE5729,0x23D967BF,
0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D,
};
uint32_t crc32_update(arrayview<uint8_t> data, uint32_t crc)
{
@@ -11,8 +41,24 @@ uint32_t crc32_update(arrayview<uint8_t> data, uint32_t crc)
crc = ~crc;
for (size_t i=0;i<len;i++)
{
crc = crctable_4bits[(crc^ ptr[i] )&0x0F] ^ (crc>>4);
crc = crctable_4bits[(crc^(ptr[i]>>4))&0x0F] ^ (crc>>4);
crc = crctable[(crc & 0xFF) ^ ptr[i]] ^ (crc>>8);
}
return ~crc;
}
//static const uint32_t crctable_4bits[]={
// 0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C,
// 0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C, 0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C,
//};
//uint32_t crc32_update(arrayview<uint8_t> data, uint32_t crc)
//{
// const uint8_t* ptr = data.ptr();
// size_t len = data.size();
// crc = ~crc;
// for (size_t i=0;i<len;i++)
// {
// crc = crctable_4bits[(crc^ ptr[i] )&0x0F] ^ (crc>>4);
// crc = crctable_4bits[(crc^(ptr[i]>>4))&0x0F] ^ (crc>>4);
// }
// return ~crc;
//}

4
arlib/file.h
View File

@@ -85,9 +85,9 @@ public:
array<byte> read() const
{
array<byte> ret;
ret.resize(this->size());
ret.resize_noinit(this->size());
size_t actual = this->read(ret, 0);
ret.resize(actual);
ret.resize_noinit(actual);
return ret;
}
static array<byte> read(cstring path)

4
arlib/global.h
View File

@@ -64,15 +64,13 @@ typedef void(*funcptr)();
#define STR_(x) #x
#define STR(x) STR_(x)
#define GCC_VER(ma,mi,pa) (ma*10000 + mi*100 + pa)
#ifdef __GNUC__
#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
#define LIKELY(expr) __builtin_expect(!!(expr), true)
#define UNLIKELY(expr) __builtin_expect(!!(expr), false)
#else
#define GCC_VERSION 0
#define LIKELY(expr) (expr)
#define UNLIKELY(expr) (expr)
#define __GNUC__ 0
#endif
//some magic stolen from http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx

12
arlib/intsafe.cpp → arlib/safeint.cpp
View File

@@ -1,5 +1,5 @@
#define INTSAFE_SELFTEST
#include "intsafe.h"
#define safeint_SELFTEST
#include "safeint.h"
#include "test.h"
#if 0 // apparently running 65536 iterations of anything under Valgrind takes a while
@@ -9,12 +9,12 @@
{ \
int au = (t)a; \
int bu = (t)b; \
intsafe<t> as = au; \
intsafe<t> bs = bu; \
safeint<t> as = au; \
safeint<t> bs = bu; \
if (as.valid() && bs.valid()) \
{ \
intsafe<t> cs1 = (1 op 8 == 256/*if op == <<*/ && b>7 ? 999 : au op bu); \
intsafe<t> cs2 = as op bs; \
safeint<t> cs1 = (1 op 8 == 256/*if op == <<*/ && b>7 ? 999 : au op bu); \
safeint<t> cs2 = as op bs; \
if (cs1.val() != cs2.val()) \
{ \
assert_msg(false, tostring(au)+#op+tostring(bu)+": expected "+tostring(cs1.val())+", got "+tostring(cs2.val())); \

58
arlib/intsafe.h → arlib/safeint.h
View File

@@ -7,7 +7,7 @@
//Overflow-safe integer class.
//If an operation would overflow, it gets a special sentinel value instead, and all further operations return that.
template<typename T> class intsafe {
template<typename T> class safeint {
T data;
#define HANDLE_BASE(stype, utype) \
@@ -64,7 +64,7 @@ template<typename T> class intsafe {
HANDLE_BASE(signed long, unsigned long)
HANDLE_BASE(signed long long, unsigned long long)
#ifndef INTSAFE_SELFTEST
#ifndef safeint_SELFTEST
#define HANDLE_EXT(name, op, type, ext) \
static inline bool name(type a, type b, type* c) \
{ \
@@ -98,7 +98,7 @@ HANDLE_EXT(lslov,<<, unsigned char, unsigned int)
#undef HANDLE_BASE
#if GCC_VERSION>=50000 && !defined(INTSAFE_SELFTEST)
#if __GNUC__>=5
#define addov __builtin_add_overflow
#define subov __builtin_sub_overflow
#define mulov __builtin_mul_overflow
@@ -109,115 +109,115 @@ public:
//static const T min = T(-1)<0 ? invalid+1 : 0;
//static const T max = T(-1)<0 ? -min : T(-2);
intsafe() : data(0) {}
template<typename U> intsafe(U val) { if (T(val)==val) data=val; else data=invalid; }
safeint() : data(0) {}
template<typename U> safeint(U val) { if (T(val)==val) data=val; else data=invalid; }
bool valid() { return data!=invalid; }
T val() { return data; }
intsafe<T>& operator=(intsafe<T> i) { data=i.val(); return *this; }
safeint<T>& operator=(safeint<T> i) { data=i.val(); return *this; }
intsafe<T> operator++(int) { intsafe<T> r = *this; *this+=1; return r; }
intsafe<T> operator--(int) { intsafe<T> r = *this; *this-=1; return r; }
intsafe<T>& operator++() { *this+=1; return *this; }
intsafe<T>& operator--() { *this+=1; return *this; }
safeint<T> operator++(int) { safeint<T> r = *this; *this+=1; return r; }
safeint<T> operator--(int) { safeint<T> r = *this; *this-=1; return r; }
safeint<T>& operator++() { *this+=1; return *this; }
safeint<T>& operator--() { *this+=1; return *this; }
#define OP(op, ope) \
intsafe<T>& operator ope(intsafe<T> i) { *this = *this op i; return *this; }
safeint<T>& operator ope(safeint<T> i) { *this = *this op i; return *this; }
ALLOPER(OP)
#undef OP
intsafe<T> operator+(intsafe<T> b)
safeint<T> operator+(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
T ret;
if (addov(val(), b.val(), &ret)) return invalid;
else return ret;
}
intsafe<T> operator-(intsafe<T> b)
safeint<T> operator-(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
T ret;
if (subov(val(), b.val(), &ret)) return invalid;
else return ret;
}
intsafe<T> operator*(intsafe<T> b)
safeint<T> operator*(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
T ret;
if (mulov(val(), b.val(), &ret)) return invalid;
else return ret;
}
intsafe<T> operator/(intsafe<T> b)
safeint<T> operator/(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//overflows in division throw SIGFPE rather than truncating
return val()/b.val();
}
intsafe<T> operator%(intsafe<T> b)
safeint<T> operator%(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//like division, overflow doesn't truncate
return val()%b.val();
}
intsafe<T> operator&(intsafe<T> b)
safeint<T> operator&(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//can't overflow
return val()&b.val();
}
intsafe<T> operator|(intsafe<T> b)
safeint<T> operator|(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//can't overflow (okay, it can become ::invalid, but that's fine)
return val()|b.val();
}
intsafe<T> operator^(intsafe<T> b)
safeint<T> operator^(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//can't overflow
return val()^b.val();
}
intsafe<T> operator<<(intsafe<T> b)
safeint<T> operator<<(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
T ret;
if (lslov(val(), b.val(), &ret)) return invalid;
else return ret;
}
intsafe<T> operator>>(intsafe<T> b)
safeint<T> operator>>(safeint<T> b)
{
if (!valid() || !b.valid()) return invalid;
//can't overflow
return val()>>b.val();
}
bool operator==(intsafe<T> b)
bool operator==(safeint<T> b)
{
if (!valid() || !b.valid()) return false;
return val()==b.val();
}
bool operator!=(intsafe<T> b)
bool operator!=(safeint<T> b)
{
if (!valid() || !b.valid()) return true; // match NaN
return val()!=b.val();
}
bool operator<(intsafe<T> b)
bool operator<(safeint<T> b)
{
if (!valid() || !b.valid()) return false;
return val()<b.val();
}
bool operator<=(intsafe<T> b)
bool operator<=(safeint<T> b)
{
if (!valid() || !b.valid()) return false;
return val()<=b.val();
}
bool operator>(intsafe<T> b)
bool operator>(safeint<T> b)
{
if (!valid() || !b.valid()) return false;
return val()>b.val();
}
bool operator>=(intsafe<T> b)
bool operator>=(safeint<T> b)
{
if (!valid() || !b.valid()) return false;
return val()>=b.val();
@@ -225,8 +225,8 @@ ALLOPER(OP)
};
#define OP(op, ope) \
template<typename T> intsafe<T> operator op(T a, intsafe<T> b) { return intsafe<T>(a) op b; } \
template<typename T> intsafe<T> operator op(intsafe<T> a, T b) { return b op intsafe<T>(a); }
template<typename T, typename U> safeint<T> operator op(U a, safeint<T> b) { return safeint<T>(a) op b; } \
template<typename T, typename U> safeint<T> operator op(safeint<T> a, U b) { return b op safeint<T>(a); }
ALLOPER(OP)
OP(==, _)
OP(!=, _)

4
arlib/thread/atomic.h
View File

@@ -13,8 +13,8 @@
//All of these functions (except store) return the value before the operation.
//(cmp)xchg obviously does, so to ease memorization, the others do too.
#if GCC_VERSION > 0
#if GCC_VERSION >= 40700
#if __GNUC__ > 0
#if __GNUC__*10+__GNUC_MINOR__ >= 47
//https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/_005f_005fatomic-Builtins.html
#define LOCKD_LOCKS_MODEL(type, model, modelname) \
inline type lock_incr ## modelname(type * val) { return __atomic_fetch_add(val, 1, model); } \