| // generic useful stuff for any C++ program |
| |
| #ifndef _TOOLS_H |
| #define _TOOLS_H |
| |
| #ifdef NULL |
| #undef NULL |
| #endif |
| #define NULL 0 |
| |
| typedef unsigned char uchar; |
| typedef unsigned short ushort; |
| typedef unsigned int uint; |
| |
| #ifdef _DEBUG |
| #ifdef __GNUC__ |
| #define ASSERT(c) if(!(c)) { asm("int $3"); } |
| #else |
| #define ASSERT(c) if(!(c)) { __asm int 3 } |
| #endif |
| #else |
| #define ASSERT(c) if(c) {} |
| #endif |
| |
| #if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1400) |
| #define RESTRICT __restrict |
| #else |
| #define RESTRICT |
| #endif |
| |
| #ifdef swap |
| #undef swap |
| #endif |
| template<class T> |
| static inline void swap(T &a, T &b) |
| { |
| T t = a; |
| a = b; |
| b = t; |
| } |
| #ifdef max |
| #undef max |
| #endif |
| #ifdef min |
| #undef min |
| #endif |
| template<class T> |
| static inline T max(T a, T b) |
| { |
| return a > b ? a : b; |
| } |
| template<class T> |
| static inline T min(T a, T b) |
| { |
| return a < b ? a : b; |
| } |
| |
| #define clamp(a,b,c) (max(b, min(a, c))) |
| #define rnd(x) ((int)(randomMT()&0xFFFFFF)%(x)) |
| #define rndscale(x) (float((randomMT()&0xFFFFFF)*double(x)/double(0xFFFFFF))) |
| #define detrnd(s, x) ((int)(((((uint)(s))*1103515245+12345)>>16)%(x))) |
| |
| #define loop(v,m) for(int v = 0; v<int(m); v++) |
| #define loopi(m) loop(i,m) |
| #define loopj(m) loop(j,m) |
| #define loopk(m) loop(k,m) |
| #define loopl(m) loop(l,m) |
| |
| |
| #define DELETEP(p) if(p) { delete p; p = 0; } |
| #define DELETEA(p) if(p) { delete[] p; p = 0; } |
| |
| #define PI (3.1415927f) |
| #define PI2 (2*PI) |
| #define SQRT2 (1.4142136f) |
| #define SQRT3 (1.7320508f) |
| #define RAD (PI / 180.0f) |
| |
| #ifdef WIN32 |
| #ifndef M_PI |
| #define M_PI 3.14159265358979323846 |
| #endif |
| #ifndef M_LN2 |
| #define M_LN2 0.693147180559945309417 |
| #endif |
| |
| #ifndef __GNUC__ |
| #pragma warning (3: 4189) // local variable is initialized but not referenced |
| #pragma warning (disable: 4244) // conversion from 'int' to 'float', possible loss of data |
| #pragma warning (disable: 4267) // conversion from 'size_t' to 'int', possible loss of data |
| #pragma warning (disable: 4355) // 'this' : used in base member initializer list |
| #pragma warning (disable: 4996) // 'strncpy' was declared deprecated |
| #endif |
| |
| #define strcasecmp _stricmp |
| #define PATHDIV '\\' |
| #else |
| #define __cdecl |
| #define _vsnprintf vsnprintf |
| #define PATHDIV '/' |
| #endif |
| |
| // easy safe strings |
| |
| #define MAXSTRLEN 260 |
| typedef char string[MAXSTRLEN]; |
| |
| inline void vformatstring(char *d, const char *fmt, va_list v, int len = MAXSTRLEN) { _vsnprintf(d, len, fmt, v); d[len-1] = 0; } |
| inline char *copystring(char *d, const char *s, size_t len = MAXSTRLEN) { strncpy(d, s, len); d[len-1] = 0; return d; } |
| inline char *concatstring(char *d, const char *s, size_t len = MAXSTRLEN) { size_t used = strlen(d); return used < len ? copystring(d+used, s, len-used) : d; } |
| |
| struct stringformatter |
| { |
| char *buf; |
| stringformatter(char *buf): buf((char *)buf) {} |
| void operator()(const char *fmt, ...) |
| { |
| va_list v; |
| va_start(v, fmt); |
| vformatstring(buf, fmt, v); |
| va_end(v); |
| } |
| }; |
| |
| #define formatstring(d) stringformatter((char *)d) |
| #define defformatstring(d) string d; formatstring(d) |
| #define defvformatstring(d,last,fmt) string d; { va_list ap; va_start(ap, last); vformatstring(d, fmt, ap); va_end(ap); } |
| |
| #define loopv(v) for(int i = 0; i<(v).length(); i++) |
| #define loopvj(v) for(int j = 0; j<(v).length(); j++) |
| #define loopvk(v) for(int k = 0; k<(v).length(); k++) |
| #define loopvrev(v) for(int i = (v).length()-1; i>=0; i--) |
| |
| template <class T> |
| struct databuf |
| { |
| enum |
| { |
| OVERREAD = 1<<0, |
| OVERWROTE = 1<<1 |
| }; |
| |
| T *buf; |
| int len, maxlen; |
| uchar flags; |
| |
| databuf() : buf(NULL), len(0), maxlen(0), flags(0) {} |
| |
| template<class U> |
| databuf(T *buf, U maxlen) : buf(buf), len(0), maxlen((int)maxlen), flags(0) {} |
| |
| const T &get() |
| { |
| static T overreadval; |
| if(len<maxlen) return buf[len++]; |
| flags |= OVERREAD; |
| return overreadval; |
| } |
| |
| databuf subbuf(int sz) |
| { |
| sz = min(sz, maxlen-len); |
| len += sz; |
| return databuf(&buf[len-sz], sz); |
| } |
| |
| void put(const T &val) |
| { |
| if(len<maxlen) buf[len++] = val; |
| else flags |= OVERWROTE; |
| } |
| |
| void put(const T *vals, int numvals) |
| { |
| if(maxlen-len<numvals) flags |= OVERWROTE; |
| memcpy(&buf[len], vals, min(maxlen-len, numvals)*sizeof(T)); |
| len += min(maxlen-len, numvals); |
| } |
| |
| int get(T *vals, int numvals) |
| { |
| int read = min(maxlen-len, numvals); |
| if(read<numvals) flags |= OVERREAD; |
| memcpy(vals, &buf[len], read*sizeof(T)); |
| len += read; |
| return read; |
| } |
| |
| int length() const { return len; } |
| int remaining() const { return maxlen-len; } |
| bool overread() const { return (flags&OVERREAD)!=0; } |
| bool overwrote() const { return (flags&OVERWROTE)!=0; } |
| |
| void forceoverread() |
| { |
| len = maxlen; |
| flags |= OVERREAD; |
| } |
| }; |
| |
| typedef databuf<char> charbuf; |
| typedef databuf<uchar> ucharbuf; |
| |
| template<class T> |
| static inline float heapscore(const T &n) { return n; } |
| |
| template<class T, class U> |
| static inline void quicksort(T *buf, int n, int (__cdecl *func)(U *, U *)) |
| { |
| qsort(buf, n, sizeof(T), (int (__cdecl *)(const void *,const void *))func); |
| } |
| |
| template <class T> struct vector |
| { |
| static const int MINSIZE = 8; |
| |
| T *buf; |
| int alen, ulen; |
| |
| vector() : buf(NULL), alen(0), ulen(0) |
| { |
| } |
| |
| vector(const vector &v) : buf(NULL), alen(0), ulen(0) |
| { |
| *this = v; |
| } |
| |
| ~vector() { shrink(0); if(buf) delete[] (uchar *)buf; } |
| |
| vector<T> &operator=(const vector<T> &v) |
| { |
| shrink(0); |
| if(v.length() > alen) growbuf(v.length()); |
| loopv(v) add(v[i]); |
| return *this; |
| } |
| |
| T &add(const T &x) |
| { |
| if(ulen==alen) growbuf(ulen+1); |
| new (&buf[ulen]) T(x); |
| return buf[ulen++]; |
| } |
| |
| T &add() |
| { |
| if(ulen==alen) growbuf(ulen+1); |
| new (&buf[ulen]) T; |
| return buf[ulen++]; |
| } |
| |
| T &dup() |
| { |
| if(ulen==alen) growbuf(ulen+1); |
| new (&buf[ulen]) T(buf[ulen-1]); |
| return buf[ulen++]; |
| } |
| |
| void move(vector<T> &v) |
| { |
| if(!ulen) |
| { |
| swap(buf, v.buf); |
| swap(ulen, v.ulen); |
| swap(alen, v.alen); |
| } |
| else |
| { |
| growbuf(ulen+v.ulen); |
| if(v.ulen) memcpy(&buf[ulen], v.buf, v.ulen*sizeof(T)); |
| ulen += v.ulen; |
| v.ulen = 0; |
| } |
| } |
| |
| bool inrange(size_t i) const { return i<size_t(ulen); } |
| bool inrange(int i) const { return i>=0 && i<ulen; } |
| |
| T &pop() { return buf[--ulen]; } |
| T &last() { return buf[ulen-1]; } |
| void drop() { ulen--; buf[ulen].~T(); } |
| bool empty() const { return ulen==0; } |
| |
| int capacity() const { return alen; } |
| int length() const { return ulen; } |
| T &operator[](int i) { ASSERT(i>=0 && i<ulen); return buf[i]; } |
| const T &operator[](int i) const { ASSERT(i >= 0 && i<ulen); return buf[i]; } |
| |
| void shrink(int i) { ASSERT(i<=ulen); while(ulen>i) drop(); } |
| void setsize(int i) { ASSERT(i<=ulen); ulen = i; } |
| |
| void deletecontents() { while(!empty()) delete pop(); } |
| void deletearrays() { while(!empty()) delete[] pop(); } |
| |
| T *getbuf() { return buf; } |
| const T *getbuf() const { return buf; } |
| bool inbuf(const T *e) const { return e >= buf && e < &buf[ulen]; } |
| |
| template<class ST> |
| void sort(int (__cdecl *cf)(ST *, ST *), int i = 0, int n = -1) |
| { |
| quicksort(&buf[i], n < 0 ? ulen : n, cf); |
| } |
| |
| void growbuf(int sz) |
| { |
| int olen = alen; |
| if(!alen) alen = max(MINSIZE, sz); |
| else while(alen < sz) alen *= 2; |
| if(alen <= olen) return; |
| uchar *newbuf = new uchar[alen*sizeof(T)]; |
| if(olen > 0) |
| { |
| memcpy(newbuf, buf, olen*sizeof(T)); |
| delete[] (uchar *)buf; |
| } |
| buf = (T *)newbuf; |
| } |
| |
| databuf<T> reserve(int sz) |
| { |
| if(ulen+sz > alen) growbuf(ulen+sz); |
| return databuf<T>(&buf[ulen], sz); |
| } |
| |
| void advance(int sz) |
| { |
| ulen += sz; |
| } |
| |
| void addbuf(const databuf<T> &p) |
| { |
| advance(p.length()); |
| } |
| |
| T *pad(int n) |
| { |
| T *buf = reserve(n).buf; |
| advance(n); |
| return buf; |
| } |
| |
| void put(const T &v) { add(v); } |
| |
| void put(const T *v, int n) |
| { |
| databuf<T> buf = reserve(n); |
| buf.put(v, n); |
| addbuf(buf); |
| } |
| |
| void remove(int i, int n) |
| { |
| for(int p = i+n; p<ulen; p++) buf[p-n] = buf[p]; |
| ulen -= n; |
| } |
| |
| T remove(int i) |
| { |
| T e = buf[i]; |
| for(int p = i+1; p<ulen; p++) buf[p-1] = buf[p]; |
| ulen--; |
| return e; |
| } |
| |
| T removeunordered(int i) |
| { |
| T e = buf[i]; |
| ulen--; |
| if(ulen>0) buf[i] = buf[ulen]; |
| return e; |
| } |
| |
| template<class U> |
| int find(const U &o) |
| { |
| loopi(ulen) if(buf[i]==o) return i; |
| return -1; |
| } |
| |
| void removeobj(const T &o) |
| { |
| loopi(ulen) if(buf[i]==o) remove(i--); |
| } |
| |
| void replacewithlast(const T &o) |
| { |
| if(!ulen) return; |
| loopi(ulen-1) if(buf[i]==o) |
| { |
| buf[i] = buf[ulen-1]; |
| } |
| ulen--; |
| } |
| |
| T &insert(int i, const T &e) |
| { |
| add(T()); |
| for(int p = ulen-1; p>i; p--) buf[p] = buf[p-1]; |
| buf[i] = e; |
| return buf[i]; |
| } |
| |
| T *insert(int i, const T *e, int n) |
| { |
| if(ulen+n>alen) growbuf(ulen+n); |
| loopj(n) add(T()); |
| for(int p = ulen-1; p>=i+n; p--) buf[p] = buf[p-n]; |
| loopj(n) buf[i+j] = e[j]; |
| return &buf[i]; |
| } |
| |
| void reverse() |
| { |
| loopi(ulen/2) swap(buf[i], buf[ulen-1-i]); |
| } |
| |
| static int heapparent(int i) { return (i - 1) >> 1; } |
| static int heapchild(int i) { return (i << 1) + 1; } |
| |
| void buildheap() |
| { |
| for(int i = ulen/2; i >= 0; i--) downheap(i); |
| } |
| |
| int upheap(int i) |
| { |
| float score = heapscore(buf[i]); |
| while(i > 0) |
| { |
| int pi = heapparent(i); |
| if(score >= heapscore(buf[pi])) break; |
| swap(buf[i], buf[pi]); |
| i = pi; |
| } |
| return i; |
| } |
| |
| T &addheap(const T &x) |
| { |
| add(x); |
| return buf[upheap(ulen-1)]; |
| } |
| |
| int downheap(int i) |
| { |
| float score = heapscore(buf[i]); |
| for(;;) |
| { |
| int ci = heapchild(i); |
| if(ci >= ulen) break; |
| float cscore = heapscore(buf[ci]); |
| if(score > cscore) |
| { |
| if(ci+1 < ulen && heapscore(buf[ci+1]) < cscore) { swap(buf[ci+1], buf[i]); i = ci+1; } |
| else { swap(buf[ci], buf[i]); i = ci; } |
| } |
| else if(ci+1 < ulen && heapscore(buf[ci+1]) < score) { swap(buf[ci+1], buf[i]); i = ci+1; } |
| else break; |
| } |
| return i; |
| } |
| |
| T removeheap() |
| { |
| T e = removeunordered(0); |
| if(ulen) downheap(0); |
| return e; |
| } |
| }; |
| |
| static inline uint hthash(const char *key) |
| { |
| uint h = 5381; |
| for(int i = 0, k; (k = key[i]); i++) h = ((h<<5)+h)^k; // bernstein k=33 xor |
| return h; |
| } |
| |
| static inline bool htcmp(const char *x, const char *y) |
| { |
| return !strcmp(x, y); |
| } |
| |
| static inline uint hthash(int key) |
| { |
| return key; |
| } |
| |
| static inline bool htcmp(int x, int y) |
| { |
| return x==y; |
| } |
| |
| template<class T> struct hashset |
| { |
| typedef T elem; |
| typedef const T const_elem; |
| |
| enum { CHUNKSIZE = 64 }; |
| |
| struct chain { T elem; chain *next; }; |
| struct chainchunk { chain chains[CHUNKSIZE]; chainchunk *next; }; |
| |
| int size; |
| int numelems; |
| chain **chains; |
| |
| chainchunk *chunks; |
| chain *unused; |
| |
| hashset(int size = 1<<10) |
| : size(size) |
| { |
| numelems = 0; |
| chunks = NULL; |
| unused = NULL; |
| chains = new chain *[size]; |
| loopi(size) chains[i] = NULL; |
| } |
| |
| ~hashset() |
| { |
| DELETEA(chains); |
| deletechunks(); |
| } |
| |
| chain *insert(uint h) |
| { |
| if(!unused) |
| { |
| chainchunk *chunk = new chainchunk; |
| chunk->next = chunks; |
| chunks = chunk; |
| loopi(CHUNKSIZE-1) chunk->chains[i].next = &chunk->chains[i+1]; |
| chunk->chains[CHUNKSIZE-1].next = unused; |
| unused = chunk->chains; |
| } |
| chain *c = unused; |
| unused = unused->next; |
| c->next = chains[h]; |
| chains[h] = c; |
| numelems++; |
| return c; |
| } |
| |
| #define HTFIND(key, success, fail) \ |
| uint h = hthash(key)&(this->size-1); \ |
| for(chain *c = this->chains[h]; c; c = c->next) \ |
| { \ |
| if(htcmp(key, c->elem)) return (success); \ |
| } \ |
| return (fail); |
| |
| template<class K> |
| T *access(const K &key) |
| { |
| HTFIND(key, &c->elem, NULL); |
| } |
| |
| template<class K> |
| T &access(const K &key, const T &elem) |
| { |
| HTFIND(key, c->elem, insert(h)->elem = elem); |
| } |
| |
| template<class K> |
| T &operator[](const K &key) |
| { |
| HTFIND(key, c->elem, insert(h)->elem); |
| } |
| |
| template<class K> |
| bool remove(const K &key) |
| { |
| uint h = hthash(key)&(size-1); |
| for(chain **p = &chains[h], *c = chains[h]; c; p = &c->next, c = c->next) |
| { |
| if(htcmp(key, c->elem)) |
| { |
| *p = c->next; |
| c->elem.~T(); |
| new (&c->elem) T; |
| c->next = unused; |
| unused = c; |
| numelems--; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void deletechunks() |
| { |
| for(chainchunk *nextchunk; chunks; chunks = nextchunk) |
| { |
| nextchunk = chunks->next; |
| delete chunks; |
| } |
| } |
| |
| void clear() |
| { |
| if(!numelems) return; |
| loopi(size) chains[i] = NULL; |
| numelems = 0; |
| unused = NULL; |
| deletechunks(); |
| } |
| |
| static inline chain *getnext(void *i) { return ((chain *)i)->next; } |
| static inline T &getdata(void *i) { return ((chain *)i)->elem; } |
| }; |
| |
| template<class K, class T> struct hashtableentry |
| { |
| K key; |
| T data; |
| |
| hashtableentry() {} |
| hashtableentry(const K &key, const T &data) : key(key), data(data) {} |
| }; |
| |
| template<class U, class K, class T> |
| static inline bool htcmp(const U *x, const hashtableentry<K, T> &y) |
| { |
| return htcmp(x, y.key); |
| } |
| |
| template<class U, class K, class T> |
| static inline bool htcmp(const U &x, const hashtableentry<K, T> &y) |
| { |
| return htcmp(x, y.key); |
| } |
| |
| template<class K, class T> struct hashtable : hashset<hashtableentry<K, T> > |
| { |
| typedef hashtableentry<K, T> entry; |
| typedef struct hashset<entry>::chain chain; |
| typedef K key; |
| typedef T value; |
| |
| hashtable(int size = 1<<10) : hashset<entry>(size) {} |
| |
| entry &insert(const K &key, uint h) |
| { |
| chain *c = hashset<entry>::insert(h); |
| c->elem.key = key; |
| return c->elem; |
| } |
| |
| T *access(const K &key) |
| { |
| HTFIND(key, &c->elem.data, NULL); |
| } |
| |
| T &access(const K &key, const T &data) |
| { |
| HTFIND(key, c->elem.data, insert(key, h).data = data); |
| } |
| |
| T &operator[](const K &key) |
| { |
| HTFIND(key, c->elem.data, insert(key, h).data); |
| } |
| |
| static inline chain *getnext(void *i) { return ((chain *)i)->next; } |
| static inline K &getkey(void *i) { return ((chain *)i)->elem.key; } |
| static inline T &getdata(void *i) { return ((chain *)i)->elem.data; } |
| }; |
| |
| #define enumerates(ht,t,e,b) loopi((ht).size) for(hashset<t>::chain *enumc = (ht).chains[i]; enumc;) { t &e = enumc->elem; enumc = enumc->next; b; } |
| #define enumeratekt(ht,k,e,t,f,b) loopi((ht).size) for(hashtable<k,t>::chain *enumc = (ht).chains[i]; enumc;) { const hashtable<k,t>::key &e = enumc->elem.key; t &f = enumc->elem.data; enumc = enumc->next; b; } |
| #define enumerate(ht,t,e,b) loopi((ht).size) for(void *enumc = (ht).chains[i]; enumc;) { t &e = (ht).getdata(enumc); enumc = (ht).getnext(enumc); b; } |
| |
| struct unionfind |
| { |
| struct ufval |
| { |
| int rank, next; |
| |
| ufval() : rank(0), next(-1) {} |
| }; |
| |
| vector<ufval> ufvals; |
| |
| int find(int k) |
| { |
| if(k>=ufvals.length()) return k; |
| while(ufvals[k].next>=0) k = ufvals[k].next; |
| return k; |
| } |
| |
| int compressfind(int k) |
| { |
| if(ufvals[k].next<0) return k; |
| return ufvals[k].next = compressfind(ufvals[k].next); |
| } |
| |
| void unite (int x, int y) |
| { |
| while(ufvals.length() <= max(x, y)) ufvals.add(); |
| x = compressfind(x); |
| y = compressfind(y); |
| if(x==y) return; |
| ufval &xval = ufvals[x], &yval = ufvals[y]; |
| if(xval.rank < yval.rank) xval.next = y; |
| else |
| { |
| yval.next = x; |
| if(xval.rank==yval.rank) yval.rank++; |
| } |
| } |
| }; |
| |
| template <class T, int SIZE> struct ringbuf |
| { |
| int index, len; |
| T data[SIZE]; |
| |
| ringbuf() { clear(); } |
| |
| void clear() |
| { |
| index = len = 0; |
| } |
| |
| bool empty() const { return !len; } |
| |
| const int length() const { return len; } |
| |
| T &add(const T &e) |
| { |
| T &t = (data[index] = e); |
| index++; |
| if(index >= SIZE) index -= SIZE; |
| if(len < SIZE) len++; |
| return t; |
| } |
| |
| T &add() { return add(T()); } |
| |
| T &operator[](int i) |
| { |
| i += index - len; |
| return data[i < 0 ? i + SIZE : i%SIZE]; |
| } |
| |
| const T &operator[](int i) const |
| { |
| i += index - len; |
| return data[i < 0 ? i + SIZE : i%SIZE]; |
| } |
| }; |
| |
| template <class T, int SIZE> struct queue |
| { |
| int head, tail, len; |
| T data[SIZE]; |
| |
| queue() { clear(); } |
| |
| void clear() { head = tail = len = 0; } |
| |
| int length() const { return len; } |
| bool empty() const { return !len; } |
| bool full() const { return len == SIZE; } |
| |
| T &added() { return data[tail > 0 ? tail-1 : SIZE-1]; } |
| T &added(int offset) { return data[tail-offset > 0 ? tail-offset-1 : tail-offset-1 + SIZE]; } |
| T &adding() { return data[tail]; } |
| T &adding(int offset) { return data[tail+offset >= SIZE ? tail+offset - SIZE : tail+offset]; } |
| T &add() |
| { |
| ASSERT(len < SIZE); |
| T &t = data[tail]; |
| tail = (tail + 1)%SIZE; |
| len++; |
| return t; |
| } |
| |
| T &removing() { return data[head]; } |
| T &removing(int offset) { return data[head+offset >= SIZE ? head+offset - SIZE : head+offset]; } |
| T &remove() |
| { |
| ASSERT(len > 0); |
| T &t = data[head]; |
| head = (head + 1)%SIZE; |
| len--; |
| return t; |
| } |
| }; |
| |
| inline char *newstring(size_t l) { return new char[l+1]; } |
| inline char *newstring(const char *s, size_t l) { return copystring(newstring(l), s, l+1); } |
| inline char *newstring(const char *s) { return newstring(s, strlen(s)); } |
| inline char *newstringbuf(const char *s) { return newstring(s, MAXSTRLEN-1); } |
| |
| #if defined(WIN32) && !defined(__GNUC__) |
| #ifdef _DEBUG |
| //#define _CRTDBG_MAP_ALLOC |
| #include <crtdbg.h> |
| inline void *__cdecl operator new(size_t n, const char *fn, int l) { return ::operator new(n, 1, fn, l); } |
| inline void __cdecl operator delete(void *p, const char *fn, int l) { ::operator delete(p, 1, fn, l); } |
| #define new new(__FILE__,__LINE__) |
| #endif |
| #endif |
| |
| const int islittleendian = 1; |
| #ifdef SDL_BYTEORDER |
| #define endianswap16 SDL_Swap16 |
| #define endianswap32 SDL_Swap32 |
| #else |
| inline ushort endianswap16(ushort n) { return (n<<8) | (n>>8); } |
| inline uint endianswap32(uint n) { return (n<<24) | (n>>24) | ((n>>8)&0xFF00) | ((n<<8)&0xFF0000); } |
| #endif |
| template<class T> inline T endianswap(T n) { union { T t; uint i; } conv; conv.t = n; conv.i = endianswap32(conv.i); return conv.t; } |
| template<> inline ushort endianswap<ushort>(ushort n) { return endianswap16(n); } |
| template<> inline short endianswap<short>(short n) { return endianswap16(n); } |
| template<> inline uint endianswap<uint>(uint n) { return endianswap32(n); } |
| template<> inline int endianswap<int>(int n) { return endianswap32(n); } |
| template<class T> inline void endianswap(T *buf, int len) { for(T *end = &buf[len]; buf < end; buf++) *buf = endianswap(*buf); } |
| template<class T> inline T endiansame(T n) { return n; } |
| template<class T> inline void endiansame(T *buf, int len) {} |
| #ifdef SDL_BYTEORDER |
| #if SDL_BYTEORDER == SDL_LIL_ENDIAN |
| #define lilswap endiansame |
| #define bigswap endianswap |
| #else |
| #define lilswap endianswap |
| #define bigswap endiansame |
| #endif |
| #else |
| template<class T> inline T lilswap(T n) { return *(const uchar *)&islittleendian ? n : endianswap(n); } |
| template<class T> inline void lilswap(T *buf, int len) { if(!*(const uchar *)&islittleendian) endianswap(buf, len); } |
| template<class T> inline T bigswap(T n) { return *(const uchar *)&islittleendian ? endianswap(n) : n; } |
| template<class T> inline void bigswap(T *buf, int len) { if(*(const uchar *)&islittleendian) endianswap(buf, len); } |
| #endif |
| |
| /* workaround for some C platforms that have these two functions as macros - not used anywhere */ |
| #ifdef getchar |
| #undef getchar |
| #endif |
| #ifdef putchar |
| #undef putchar |
| #endif |
| |
| struct stream |
| { |
| virtual ~stream() {} |
| virtual void close() = 0; |
| virtual bool end() = 0; |
| virtual long tell() { return -1; } |
| virtual bool seek(long offset, int whence = SEEK_SET) { return false; } |
| virtual long size(); |
| virtual int read(void *buf, int len) { return 0; } |
| virtual int write(const void *buf, int len) { return 0; } |
| virtual int getchar() { uchar c; return read(&c, 1) == 1 ? c : -1; } |
| virtual bool putchar(int n) { uchar c = n; return write(&c, 1) == 1; } |
| virtual bool getline(char *str, int len); |
| virtual bool putstring(const char *str) { int len = (int)strlen(str); return write(str, len) == len; } |
| virtual bool putline(const char *str) { return putstring(str) && putchar('\n'); } |
| virtual int printf(const char *fmt, ...) { return -1; } |
| virtual uint getcrc() { return 0; } |
| |
| template<class T> bool put(T n) { return write(&n, ES_SIZEOV(n)) == ES_SIZEOV(n); } |
| template<class T> bool putlil(T n) { return put<T>(lilswap(n)); } |
| template<class T> bool putbig(T n) { return put<T>(bigswap(n)); } |
| |
| template<class T> T get() { T n; return read(&n, ES_SIZEOV(n)) == ES_SIZEOV(n) ? n : 0; } |
| template<class T> T getlil() { return lilswap(get<T>()); } |
| template<class T> T getbig() { return bigswap(get<T>()); } |
| }; |
| |
| #endif |
| |
