// Only include once
#ifndef TYPES_INCLUDED
#define TYPES_INCLUDED 1
// Include C headers
#include <climits>
#include <cfloat>
// Define 1-bit integer
typedef bool int1;
// Define 8-bit integer
typedef signed char int8;
typedef unsigned char uint8;
// Define 16-bit integer
typedef signed short int int16;
typedef unsigned short int uint16;
// Define 32-bit integer
typedef signed int int32;
typedef unsigned int uint32;
// Define 64-bit integer
typedef signed long long int int64;
typedef unsigned long long int uint64;
// Size function - returns lowest size in bytes required to set value
uint8 requirement(int64 value)
{
if (value>=CHAR_MIN || value<=CHAR_MAX)
{
return 1;
}
else if (value>=SHRT_MIN || value<=SHRT_MAX)
{
return 2;
}
else if (value>=INT_MIN || value<=INT_MAX)
{
return 4;
}
else
{
return 8;
}
}
// Define variable-sized integer
class varint
{
// Make pointer to value
public: void *value;
private: uint8 size;
// Make constructor
public: varint() { resize(1);set(0); }
public: varint(int64 x) { resize(requirement(x));set(x); };
public: varint(int64 x,uint8 size) { resize(size);set(x); };
// Set function - sets value to *value
private: void set(int64 x)
{
switch (size)
{
case 1:
int8 *value8;value8=(int8*)value;*value8=x;
break;
case 2:
int16 *value16;value16=(int16*)value;*value16=x;
break;
case 4:
int32 *value32;value32=(int32*)value;*value32=x;
break;
case 8:
int64 *value64;value64=(int64*)value;*value64=x;
break;
}
}
// Get function - gets value of *value
private: int64 get()
{
switch (size)
{
case 1:
int8 *value8=(int8*)value;
return (int64)*value8;
break;
case 2:
int16 *value16=(int16*)value;
return (int64)*value16;
break;
case 4:
int32 *value32=(int32*)value;
return (int32)*value32;
break;
case 8:
int64 *value64=(int64*)value;
return (int64)*value64;
break;
}
}
// Resize function
public: void resize(uint8 bytes)
{
// Invalid number of bytes?
if (bytes!=1 && bytes!=2 && bytes!=4 && bytes!=8)
{
return;
}
// Resize if lower size is given only if lower == true
if (sizeof(value)!=bytes)
{
void *temp=value;
delete value;
switch (bytes)
{
case 1:
void *value=new int8;value=temp;
break;
case 2:
void *value=new int16;value=temp;
break;
case 4:
void *value=new int32;value=temp;
break;
case 8:
void *value=new int64;value=temp;
break;
}
}
// Set size variable
size=bytes;
}
// Get size function
public: size_t getsize()
{
return (size_t)size;
}
// Return operators
&operator int64() { return get(); }
&operator int32() { return get(); }
&operator int16() { return get(); }
&operator int8() { return get(); }
// Define operators
int64 &operator =(int64 x) { if (requirement(x)>sizeof(value)) { resize(sizeof(x)); } set(x);return get(); }
int32 &operator =(int32 x) { if (requirement(x)>sizeof(value)) { resize(sizeof(x)); } set(x);return get(); }
int16 &operator =(int16 x) { if (requirement(x)>sizeof(value)) { resize(sizeof(x)); } set(x);return get(); }
int8 &operator =(int8 x) { if (requirement(x)>sizeof(value)) { resize(sizeof(x)); } set(x);return get(); }
}
// Define decimals
typedef float dec32;
typedef double dec64;
typedef long double dec96;
// Define special
typedef std::string str;
// End include
#endif
Now, you know what I do when I'm bored.
Just in case you didn't pick up what this is, it's a header for various type definitions and aliases. The one I'm having trouble with is varint.
varint is a variable-sized integer. Essentially, it'll only be as big as it needs to be. If I want to make a variable with a value of 0, why do I need more than 1 byte? If it's 256, however, I'll need it to be 2 bytes. Of course, you're probably thinking: "why the hell do I care; it's only a few bytes". Well, err, I don't know what to say. But, whenever I try to compile this, g++ borks and returns tons of warnings. Anyone have any idea what I need to do to fix this? And, just for the record, it's not done; I still have the other operators to do.