axcel.h

Go to the documentation of this file.

#ifndef AXCEL
#define AXCEL
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cstdarg>
#include <cmath>
#include <climits>
#include <cctype>
#include <deque>

#ifdef _WIN32
#define _WIN32_WINNT 0x0600
#define WINVER 0x0600
#define WIN32_LEAN_AND_MEAN
#define popen _popen
#define pclose _pclose
#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <conio.h>
#include <io.h>
#include <fcntl.h>
#include <tlhelp32.h>
#include <errno.h>

#undef min
#include <time.h>
#else
#include <errno.h>
#include <ctime>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <termios.h>
#include <wordexp.h>

#include <signal.h>
#include <pthread.h>
#include <semaphore.h>

#include <dlfcn.h>
#endif

#define use using namespace

#define unless(x) if (!(x))

#define until(x) while (!(x))

#define loop() for (;;)

#define crap(...)\
        if (1) {\
        fprintf(stderr, __VA_ARGS__);\
        return;}
        
#define craps(x, ...) \
        if (1) {\
        fprintf(stderr, __VA_ARGS__);\
        return x; }

#define warn(...) \
        fprintf(stderr, __VA_ARGS__);

typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;

template <typename T>
inline bool gt(T a, T b) { return a > b; }

template <typename T>
inline bool lt(T a, T b) { return a < b; }

template <typename T>
inline bool eq(T a, T b) { return a == b; }

template <typename T>
inline bool gte(T a, T b) { return a >= b; }

template <typename T>
inline bool lte(T a, T b) { return a <= b; }

template <typename T>
inline bool neq(T a, T b) { return a != b; }

char* strcpy2(char* s1, const char* s2);
char* strncpy2(char* s1, const char* s2, size_t n);

const char* strstrs(const char* src, ...);

int strstrc(const char* src, ...);

namespace axcel {
class object;
class data;
class string;
class console;
class exception;

namespace io {
        class iob;
        class iofmt;
        class input;
        class output;
        class ios;
};

namespace fs {
        class file;
};

namespace proc {
        class thread;
        class mutex;
        class semaphore;
        class pstream;
        class library;
        class environment;
};

namespace net {
        class ipaddr;
        class dgram;
        

        namespace socket {
                class tcp;
                class udp;
        };
        namespace irc {
                class msg;
        };
        namespace http {
                class field;
                class request;
                class header;
                class response;
                class query;
        };
};      


class object {
protected: int errnum;
public:
        object() { errnum = 0; }
        
        virtual string type() = 0;
        
        virtual operator string () = 0;
        
        string tostr();
        
        exception error();
        
};

namespace io {
class iofmt : virtual public object {
public:
        virtual string type();
        virtual operator string ();
        size_t width;
        size_t precis;
        iofmt();
        bool bin(int i = -1);
        bool btoa(int i = -1);
        bool base(int i = -1);
        bool zpad(int i = -1);
        bool sign(int i = -1);
        bool deaf(int i = -1);
        bool dec(int i = -1);
        bool hex(int i = -1);
        bool oct(int i = -1);
        bool ltrim(int i = -1);
        bool endnl(int i = -1);
        bool left(int i = -1);
        bool right(int i = -1);
        bool fix(int i = -1);
        bool sci(int i = -1);
private:
        bool gsbit(int i, long j);
        long lfmt;
};

class iob : virtual public object {
public:
        virtual string type();
        virtual operator string ();
        //io::iob* knot;
        iob() { /*knot = 0;*/ istat = 0; heal(); }
        iofmt fmt;
        bool ok();
        bool hurt();
        bool dead();
        bool eof();
        void heal();
        void hit();
        void kill();
        void drain();
private:
        int istat;
};

class input : virtual public iob {
public:
        virtual string type();
        
        virtual int getc() = 0;
        virtual char* gets(char* s, int size = 0);
        virtual string gets(int size = 0);
        virtual int scanf(const char* format, ...);
        virtual size_t read(char* ptr, size_t size, size_t nmemb);
        virtual data read(size_t size, size_t nmemb);
        virtual data dump();
        virtual string drink(const char* eol = 0);
        virtual data suck(const char* eol, size_t len = 0);
        input& operator>> (bool& val);
        input& operator>> (short& val);
        input& operator>> (unsigned short& val);
        input& operator>> (int& val);
        input& operator>> (unsigned int& val);
        input& operator>> (long& val);
        input& operator>> (unsigned long& val);
        input& operator>> (long long& val);
        input& operator>> (unsigned long long& val);
        input& operator>> (float& val);
        input& operator>> (double& val);
        input& operator>> (long double& val);
        input& operator>> (void*& val);
        input& operator>> (char& c);
        input& operator>> (char* s);
        input& operator>> (string& s);
private:
        char* in_fmt(char* s, char d, char m);
};

class output : virtual public iob {
public:
        virtual string type();
        
        virtual int putc(int c) = 0;
        virtual int puts(const char* s);
        virtual int printf(const char* format, ...);
        virtual size_t write(const char* ptr, size_t size, size_t nmemb);
        virtual size_t write(data d);
        output& operator<< (object& o);
        output& operator<< (bool val);
        output& operator<< (short val);
        output& operator<< (unsigned short val);
        output& operator<< (int val);
        output& operator<< (unsigned int val);
        output& operator<< (long val);
        output& operator<< (unsigned long val);
        output& operator<< (float val);
        output& operator<< (double val);
        output& operator<< (long double val);
        output& operator<< (const void* val);
        output& operator<< (char c);
        output& operator<< (signed char c);
        output& operator<< (unsigned char c);
        output& operator<< (const char* s);
        output& operator<< (string s);
        output& put(object& o);
        inline output& put(bool val) { return operator<<(val); }
        inline output& put(short val) { return operator<<(val); }
        inline output& put(unsigned short val) { return operator<<(val); }
        inline output& put(int val) { return operator<<(val); }
        inline output& put(long val) { return operator<<(val); }
        inline output& put(unsigned long val) { return operator<<(val); }
        inline output& put(float val) { return operator<<(val); }
        inline output& put(double val) { return operator<<(val); }
        inline output& put(long double val) { return operator<<(val); }
        inline output& put(const void* val) { return operator<<(val); }
        inline output& put(char c) { return operator<<(c); }
        inline output& put(signed char c) { return operator<<(c); }
        inline output& put(unsigned char c) { return operator<<(c); }
        inline output& put(const char* s) { return operator<<(s); }
        output& echo(object& o);
        inline output& echo() { putc('\n'); return *this; }
        inline output& echo(bool val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(short val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(unsigned short val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(int val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(size_t val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(long val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(unsigned long val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(float val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(double val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(long double val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(const void* val) { operator<<(val); putc('\n'); return *this; }
        inline output& echo(char c) { operator<<(c); putc('\n'); return *this; }
        inline output& echo(signed char c) { operator<<(c); putc('\n'); return *this; }
        inline output& echo(unsigned char c) { operator<<(c); putc('\n'); return *this; }
        inline output& echo(const char* s) { operator<<(s); putc('\n'); return *this; }
        output& put(string s);
        output& echo(string s);
        
private:
        char* out_fmt(char* s, char t, const char* m);
};

class ios : virtual public input, virtual public output {
public:
        string type();
        operator string();
        ios& operator<< (object& o);
        ios& operator<< (bool val);
        ios& operator<< (short val);
        ios& operator<< (unsigned short val);
        ios& operator<< (int val);
        ios& operator<< (unsigned int val);
        ios& operator<< (long val);
        ios& operator<< (unsigned long val);
        ios& operator<< (float val);
        ios& operator<< (double val);
        ios& operator<< (long double val);
        ios& operator<< (const void* val);
        ios& operator<< (char c);
        ios& operator<< (signed char c);
        ios& operator<< (unsigned char c);
        ios& operator<< (const char* s);
        ios& operator<< (string s);
        ios& put(object& o);
        ios& put(string s);
        ios& echo(object& o);
        ios& echo(string s);
        ios& put(bool val);
        ios& put(short val);
        ios& put(unsigned short val);
        ios& put(int val);
        ios& put(long val);
        ios& put(unsigned long val);
        ios& put(float val);
        ios& put(double val);
        ios& put(long double val);
        ios& put(const void* val);
        ios& put(char c);
        ios& put(signed char c);
        ios& put(unsigned char c);
        ios& put(const char* s);
        ios& echo();
        ios& echo(bool val);
        ios& echo(short val);
        ios& echo(unsigned short val);
        ios& echo(int val);
        ios& echo(size_t val);
        ios& echo(long val);
        ios& echo(unsigned long val);
        ios& echo(float val);
        ios& echo(double val);
        ios& echo(long double val);
        ios& echo(const void* val);
        ios& echo(char c);
        ios& echo(signed char c);
        ios& echo(unsigned char c);
        ios& echo(const char* s);
        ios& operator>> (bool& val);
        ios& operator>> (short& val);
        ios& operator>> (unsigned short& val);
        ios& operator>> (int& val);
        ios& operator>> (unsigned int& val);
        ios& operator>> (long& val);
        ios& operator>> (unsigned long& val);
        ios& operator>> (long long& val);
        ios& operator>> (unsigned long long& val);
        ios& operator>> (float& val);
        ios& operator>> (double& val);
        ios& operator>> (long double& val);
        ios& operator>> (void*& val);
        ios& operator>> (char& c);
        ios& operator>> (char* s);
        ios& operator>> (string& s);
};

}

class data : virtual public io::ios {
protected:
        size_t pos, mlen, slen;
public:
        char* buf;

        virtual string type();
        
        virtual operator string ();
        data(const data& d);
        char& operator [](int i);
        data& operator= (const char* s);
        data& operator= (object& o);
        data& operator= (data d);
        bool operator== (data d);
        bool operator== (const char* s);
        bool operator== (object& o);
        bool operator!= (data d);
        bool operator!= (const char* s);
        bool operator!= (object& o);
        data();
        ~data();
        virtual int getc();
        virtual int putc(int c);
        virtual bool seek(long offset, int whence);
        virtual size_t tell();
        virtual void rewind();
        virtual void unwind();
        virtual bool ffwd(size_t offset);
        virtual bool prev(size_t offset);
        virtual size_t len() const;
        virtual void realloc(size_t n);
        virtual operator void* () { return (void*)buf; }
        virtual operator char* () { return buf; }
};

class string : virtual public data {
public:
        virtual string type();
        virtual operator string ();
        string();
        string(const char* s);
        string(size_t n);
        string(const string& s);
        string(const data& s);
        ~string();
        int getc();
        int putc(int c);
        string& clear();
        bool empty();
        size_t len();
        size_t msize() const;
        string cat(const char* s, size_t n = 0);
        string cat(int c, size_t n = 1);
        string prep(const char* s, size_t n = 0);
        string prep(int c, size_t n = 1);
        long chr(int c, size_t index = 0);
        long rchr(int c);
        long str(const char* s, size_t index = 0);
        long rstr(const char* s);
        bool starts(const char* s);
        bool starts(int c);
        bool ends(const char* s);
        bool ends(int c);
        bool is(const char* s);
        bool is(int c);
        string cpy(const char* src, size_t index = 0, size_t count = 0);
        string cpy(int c, size_t index = 0, size_t count = 1);
        //string ncpy(const char* src, size_t n = 0, size_t index = 0);
        size_t spn(const char* accept, size_t index = 0);
        size_t spn(int c, size_t index = 0);
        size_t cspn(const char* reject, size_t index = 0);
        size_t cspn(int c, size_t index = 0);
        string fry();
        long pbrk(const char* accept, size_t index = 0);
        long rpbrk(const char* accept, size_t index = 0);
        string substr(size_t start, size_t count);
        string tok(size_t index, const char* delim = " ");
        string tok(size_t index, int delim); 
        size_t ntok(const char* delim = " ");
        size_t ntok(int delim);
        long itok(size_t index, const char* delim = " ");
        long itok(size_t index, int delim);
        std::deque<axcel::string> split(const char* delim = " ");
        std::deque<axcel::string> split(int delim);
        string wrap(size_t len, const char* eol = "\r\n");
        string left(size_t n);
        string right(size_t n);
        size_t nchr(int ch);
        size_t nstr(const char* str);
        string rep(const char* oldstr, const char* newstr);
        string rep(int oldc, int newc);
        string ins(size_t index, const char* str);
        string ins(size_t index, int c);
        string rm(size_t index, size_t n);
        string rev(size_t start = 0, size_t count = 0);
        string dup(int i);
        string ror(size_t i = 1, size_t index = 0, size_t count = 0);
        string rol(size_t i = 1, size_t index = 0, size_t count = 0);
        string shl(size_t n = 1);
        string shr(size_t n = 1);
        string lc(size_t start = 0, size_t count = 0);
        string uc(size_t start = 0, size_t count = 0);
        string q();
        string qq();
        string qx();
        char& front();
        char& back();
        string esc(const char* format, int (*charfilter)(int) = NULL);
        string esc(const char* format, const char* chrs);
        string uesc(const char* format, int (*charfilter)(int) = NULL);
        string uesc(const char* format, const char* chrs);
        string untag(int opentag = '<', int closetag = '>');
        //string htmlesc();
        //string htmluesc();
        string ltrim();
        string rtrim();
        string strip();
        string chop();
        string chomp(const char* eat = "\r\n");
        string chomp(char eat);
        string cut();
        string munch(const char* eat);
        string munch(char eat);
        string prefix(const char* str);
        string suffix(const char* str);
        
        inline string slurp(char c) { return shl(chr(c) + 1); }
        
        inline string rslurp(char c) { return shl(rchr(c) + 1); }
        
        inline string burn(char c) { if (chr(c) > -1) return shr(len() - chr(c)); else return *this; }
        
        inline string rburn(char c) { if (chr(c) > -1) return shr(len() - rchr(c)); else return *this; }
        
        inline string slurp(const char* s) { return shl(str(s) + strlen(s)); }
        
        inline string rslurp(const char* s) { return shl(rstr(s) + strlen(s)); }
        
        inline string burn(const char* s) { if (str(s) > -1) return shr(len() - str(s)); else return *this; }
        
        inline string rburn(const char* s) { if (str(s) > -1) return shr(len() - rstr(s)); else return *this; }
        string& swap(string& s);
        string center(size_t newlen, const char* left, const char* right);
        string center(size_t newlen, int left, int right);
        string center(size_t newlen, const char* pad = " ");
        string center(size_t newlen, int pad);
        string lpad(size_t newlen, const char* pad = " ");
        string lpad(size_t newlen, int pad);
        string rpad(size_t newlen, const char* pad = " ");
        string rpad(size_t newlen, int pad);
        string squeeze(const char* chrs = 0);
        string squeeze(int chr);
        string alnums();
        string alphas();
        string cntrls();
        string digits();
        string graphs();
        string lowers();
        string prints();
        string puncts();
        string spaces();
        string uppers();
        string xdigits();
        string ctypes(int (*cfunc)(int));
        string ctypes(const char* chrs);
        bool isalnum();
        bool isalpha();
        bool iscntrl();
        bool isdigit();
        bool isgraph();
        bool islower();
        bool isprint();
        bool ispunct();
        bool isspace();
        bool isupper();
        bool isxdigit();
        bool isctype(int (*cfunc)(int));
        bool isctype(const char* chrs);
        string inc();
        string dec();
        string incn();
        string decn();
        string add(int n);
        string add(const char* s);
        string sub(int n);
        string sub(const char* s);
        string addn(int n);
        string addn(const char* s);
        string subn(int n);
        string subn(const char* s);
        unsigned short cksum();
        int cmpstr(const char* s, ...);
        int cmpinstr(const char* s, ...);
        int cmpleft(const char* s, ...);
        int cmpright(const char* s, ...);
        string& operator =(string s);
        string& operator =(const char* s);
        string& operator =(const data& d);
        //string& operator =(char c);
        string operator +(const char* str);
        string operator +(char c);
        string& operator +=(const char* str);
        string& operator +=(char c);
        string operator -(const char* str);
        string operator -(char c);
        string& operator -=(const char* str);
        string& operator -=(char c);
        bool operator ==(const char* s);
        bool operator ==(char c);
        bool operator !=(const char* s);
        bool operator !=(char c);
        char& operator [](int i);
        string operator *(int i);
        string& operator *=(int i);
        string operator ()();
        operator const char*() { return buf; }
        operator char*() { return buf; }
        string& operator ++();
        string operator ++(int foo);
        string& operator --();
        string operator --(int foo);
};

class fs::file : virtual public io::ios {
public:
        virtual string type();
        virtual operator string ();
        bool operator! ();
        FILE* fd;
        file() {}
        file(const char* name, const char* mode);
        file(FILE* f);
        file(int fh, const char* mode);
        int putc(int c);
        int getc();
        //string gets(int size = 0);
        FILE* open(const char* fname, const char* mode);
        FILE* dopen(int fh, const char* mode);
        FILE* reopen(const char* fname, const char* mode);
        bool close();
        bool flush();
        bool seek(long offset, int whence);
        long tell();
        bool rewind();
        bool unwind();
        bool ffwd(long offset);
        bool prev(long offset);
        bool nobuf();
        bool lbuf();
        bool fbuf(char* buf, size_t size);
        int ungetc(int c);
        operator FILE*() { return fd; }
private:
        string filename;
};

class net::ipaddr : virtual public object {
private:
        bool cmp(const char* s, struct in_addr * ia4, struct in6_addr * ia6, int op);
#ifdef _WIN32
        void initwsa();
#endif
public:
        virtual string type();
        virtual operator string ();
        int af;
        union { struct in_addr addr4; struct in6_addr addr6; };
        ipaddr(const char* s = "127.0.0.1");
        ipaddr(struct in_addr* s);
        ipaddr(struct in6_addr* s);
#ifdef _WIN32
        ~ipaddr() { WSACleanup(); }
#endif
        net::ipaddr& operator= (const char* s);
        net::ipaddr& operator= (struct in_addr* s);
        net::ipaddr& operator= (struct in6_addr* s);
        bool operator== (const char* s);
        bool operator== (struct in_addr* s);
        bool operator== (struct in6_addr* s);
        bool operator!= (const char* s);
        bool operator!= (struct in_addr* s);
        bool operator!= (struct in6_addr* s);
        bool operator> (const char* s);
        bool operator> (struct in_addr* s);
        bool operator> (struct in6_addr* s);
        bool operator< (const char* s);
        bool operator< (struct in_addr* s);
        bool operator< (struct in6_addr* s);
        bool operator>= (const char* s);
        bool operator>= (struct in_addr* s);
        bool operator>= (struct in6_addr* s);
        bool operator<= (const char* s);
        bool operator<= (struct in_addr* s);
        bool operator<= (struct in6_addr* s);
        net::ipaddr operator+ (int i);
        net::ipaddr operator- (int i);
        net::ipaddr& operator+= (int i);
        net::ipaddr& operator-= (int i);
        net::ipaddr& operator++ ();
        net::ipaddr operator++ (int foo);
        net::ipaddr& operator-- ();
        net::ipaddr operator-- (int foo);
        
};

class net::socket::tcp : virtual public io::ios {
private: int af;
#ifdef _WIN32
        int wsatoerr(int i);
#endif
public:
        virtual string type();
        virtual operator string ();
#ifdef _WIN32
        SOCKET fd;
        ~tcp();
#else
        int fd;
#endif
        tcp();
        int putc(int c);
        int getc();
        data dump();
        int puts(const char* s);
        int send(const char* buf, size_t len);
        int recv(char* buf, size_t len);
        bool connect(const char* host, const char* port);
        bool listen(const char* port, int backlog);
        bool accept(tcp& f);
        bool blocking(int i = -1);
        bool ready();
        bool close();
        bool connected();
        string ip();
        string name();
#ifdef _WIN32
private:
        bool blking;
#endif
};

class net::socket::udp : virtual public object {
public:
#ifdef _WIN32
        SOCKET fd;
#else
        int fd;
#endif
        udp();
        ~udp();
        virtual string type();
        virtual operator string();
        int post(dgram dg);
        net::dgram get();
        bool bind(const char* port);
        void unbind();
        int check();
};

class net::dgram : virtual public object {
public:
        virtual string type();
        virtual operator string ();
        net::ipaddr ip;
        unsigned short port;
        data msg;
};

#ifdef _WIN32
#define daylight _daylight
struct tm *localtime_r (const time_t *, struct tm * result);
struct tm *gmtime_r (const time_t *, struct tm * result);
#endif

time_t axcel_timegm(struct tm* tm);

class timer : virtual public object {
public:
        virtual string type();
        virtual operator string ();
        
        bool UTC;
        timer();
        timer(const char* s);
        struct tm t;
        int sec();
        int min();
        int hour();
        int mday();
        int mon();
        int year();
        int wday();
        string str();
        timer& operator= (const char* s);
        timer& operator= (struct tm* tm);
        timer& operator= (time_t raw);
        bool operator== (const char* s);
        bool operator!= (const char* s);
        bool operator> (const char* s);
        bool operator< (const char* s);
        bool operator<= (const char* s);
        bool operator>= (const char* s);
        timer operator+ (const char* s);
        timer operator- (const char* s);
        timer& operator+= (const char* s);
        timer& operator-= (const char* s);
        static string ltime();
        static string utime();
private:

        template <typename T>
        bool op(bool (*cmp)(T, T), const char* s) {
                int i;
                const char* c;
                struct tm z;
                time_t a = 0, b = 0;
                z.tm_sec = -1;
                z.tm_min = -1;
                z.tm_hour = -1;
                z.tm_mday = -1;
                z.tm_mon = -1;
                z.tm_year = -1;
                z.tm_wday = -1;
                for (c = strpbrk(s, "0123456789"); c != NULL; c = strpbrk(c, "0123456789")) {
                        i = atoi(c);
                        while (isdigit(*c)) c++;
                        if (*c == ':') {
                                z.tm_hour = i;
                                z.tm_min = atoi(++c);
                                while (isdigit(*c)) c++;
                                if (*c == ':') z.tm_sec = atoi(++c);
                                while (isdigit(*c)) c++;
                                if (isspace(*c)) c++;
                                if (!strncmp(c, "PM", 2) || !strncmp(c, "pm", 2) || !strncmp(c, "p.m.", 4))
                                {       if (z.tm_hour != 12) z.tm_hour += 12; }
                                else if (!strncmp(c, "AM", 2) || !strncmp(c, "am", 2) || !strncmp(c, "a.m.", 4))
                                {       if (z.tm_hour == 12) z.tm_hour = 0; }
                        } else {
                                if (i > 0 && i < 32) z.tm_mday = i;
                                else z.tm_year = i - 1900;
                        }
                }
                if (strstr(s, "Sun")) z.tm_wday = 0;
                else if (strstr(s, "Mon")) z.tm_wday = 1;
                else if (strstr(s, "Tue")) z.tm_wday = 2;
                else if (strstr(s, "Wed")) z.tm_wday = 3;
                else if (strstr(s, "Thu")) z.tm_wday = 4;
                else if (strstr(s, "Fri")) z.tm_wday = 5;
                else if (strstr(s, "Sat")) z.tm_wday = 6;
                if (strstr(s, "Jan")) z.tm_mon = 0;
                else if (strstr(s, "Feb")) z.tm_mon = 1;
                else if (strstr(s, "Mar")) z.tm_mon = 2;
                else if (strstr(s, "Apr")) z.tm_mon = 3;
                else if (strstr(s, "May")) z.tm_mon = 4;
                else if (strstr(s, "Jun")) z.tm_mon = 5;
                else if (strstr(s, "Jul")) z.tm_mon = 6;
                else if (strstr(s, "Aug")) z.tm_mon = 7;
                else if (strstr(s, "Sep")) z.tm_mon = 8;
                else if (strstr(s, "Oct")) z.tm_mon = 9;
                else if (strstr(s, "Nov")) z.tm_mon = 10;
                else if (strstr(s, "Dec")) z.tm_mon = 11;
                if (z.tm_sec != -1) { a += z.tm_sec; b += t.tm_sec; }
                if (z.tm_min != -1) { a += z.tm_min * 60; b += t.tm_min * 60; }
                if (z.tm_hour != -1) { a += z.tm_hour * 60 * 60; b += t.tm_hour * 60 * 60; }
                if (z.tm_mday != -1) { a += z.tm_mday * 60 * 60 * 24; b += t.tm_mday * 60 * 60 * 24; }
                if (z.tm_mon != -1) { a += z.tm_mon * 60 * 60 * 24 * 30; b += t.tm_mon * 60 * 60 * 24 * 30; }
                if (z.tm_year != -1) { a += z.tm_year * 60 * 60 * 24 * 30 * 12; b += t.tm_year * 60 * 60 * 24 * 30 * 12; }
                if (z.tm_wday != -1) { a += z.tm_wday * 60 * 60 * 24; b += t.tm_wday * 60 * 60 * 24; }
                if (!(cmp(b, a))) return false;
                return true;
        }
};


namespace color {
#ifndef _WIN32
enum {
        black, red, green, yellow, blue,
        purple, aqua, white
};
#else
enum {
        black = 0,
        blue = FOREGROUND_BLUE, 
        green = FOREGROUND_GREEN,
        red = FOREGROUND_RED,
        aqua = FOREGROUND_BLUE | FOREGROUND_GREEN,
        purple = FOREGROUND_BLUE | FOREGROUND_RED, 
        yellow = FOREGROUND_GREEN | FOREGROUND_RED,
        white = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
};
#endif
}

class console : virtual public io::ios {
public:
        virtual string type();
        virtual operator string ();
        FILE* in;
        FILE* out;
        console() { in = stdin; out = stdout; }
        int putc(int c);
        int getc();
        int getch();
        int getche();
        bool kbhit();
        data dump();
        console& putcr();
        console& putbs();
        console& cls();
        console& bel();
        console& setxy(int x, int y);
        console& setx(int x);
        console& sety(int y);
        console& up(int n);
        console& dn(int n);
        console& lt(int n);
        console& rt(int n);
        console& rmln();
        console& fglite();
        console& fgdark();
        console& fgcol(short color);
        console& bgcol(short color);
private:
        char s[8];
#ifdef _WIN32
        HANDLE conout;
        CONSOLE_SCREEN_BUFFER_INFO bi;
        HANDLE coninfo(HANDLE* h, CONSOLE_SCREEN_BUFFER_INFO* bi);
#endif
};

extern console con;

template <typename type>
type stoi(const char* s, int base = 10) {
   bool neg = false;     
   type ret = 0, num, place = 1;
   while (isspace(*s)) s++;
   if (*s == '-') { neg = true; s++; }
   else if (*s == '+') s++;
   if (base == 0) {
      if (*s == '0') {
         if (tolower(s[1]) == 'x') { base = 16; s += 2; }
         else { base = 8; s++; }
      } else base = 10;
   } else {
      if (*s == '0') {
         if (tolower(s[1]) == 'x' && base == 16) s += 2;
         else if (base == 8) s++;
         else return 0;
      }
   }
   const char \
      *set = "0123456789abcdefghijklmnopqrstuvwxyz",
      *t = s + strlen(s) - 1,
      *tmp;
   for (t = s; *t; t++) {
                tmp = strchr(set, tolower(*t));
                if (tmp == NULL) break;
                if (tmp - set >= base) break;
   }
   t--;
   if (t <= s) {
        tmp = strchr(set, tolower(*t));
        if (tmp == NULL) return 0;
        if (tmp - set >= base) return 0;
   }
   for (; t >= s; t--, place *= base) {
      if (!place) return 0;
      tmp = strchr(set, tolower(*t));
      if (tmp == NULL) return 0;
      if (tmp - set >= base) return 0;
      num = (tmp - set) * place;
      if (neg) {
         if ((type)(ret - (num ? num : place) > ret))
                        return 0;
         ret -= num;
         if (ret >= 0 && num != 0) return 0;
      } else {
         if ((type)(ret + (num ? num : place) < ret)) return 0;
         ret += num;
         if (ret <= 0 && num != 0) return 0;
      }
   }
   return ret;
}

template <typename type>
type stof(const char* s) {
        int i;
        type ret = 0, num = 0, place = 1;
        bool neg = false;
        const char *t;
        bool pineapple = false;
        while (isspace(*s)) s++;
        if (*s == '-') { neg = true; s++; }
        else if (*s == '+') s++;
        if ((t = strchr(s, '.')) == NULL)
                if ((t = strchr(s, 'e')) == NULL)
                        t = s + strlen(s);
        for (t--; t >= s; t--, place *= 10) {
                goto stof_smoothie;
                stof_forloop_1: ;
        }
        if ((t = strchr(s, '.')) == NULL) goto stof_blend_ice;
        pineapple = true;
        for (t++, place = 0.1;
                *t != 'e' && *t != 0;
        t++, place /= 10) {
                goto stof_smoothie;
                stof_forloop_2: ;
        }
        
stof_blend_ice:
        if ((t = strchr(s, 'e')) == NULL)
                return ret;     
        else {
                i = stoi<int>(t + 1, 10);
                if (i < 0) {
                        for (; i < 0; i++) {
                                num = ret / 10;
                                if (num >= ret) return 0;
                                else ret = num;
                        }
                } else {
                        for (; i > 0; i--) {
                                num = ret * 10;
                                if (num <= ret) return 0;
                                else ret = num;
                        }
                }
        }
        return ret;
stof_smoothie:
        if (!place)
                if (neg) return 0;
        if (!isdigit(*t)) return 0;
        num = (*t - '0') * place;
        if (neg) {
                if ((type)(ret - (num ? num : place) > ret))
                        return 0;
                ret -= num;
                if (ret >= 0 && num != 0) return 0;
        } else {
                if ((type)(ret + (num ? num : place) <= ret)) return 0;
                        ret += num;
                if (ret <= 0 && num != 0) return 0;
        }
        if (pineapple) goto stof_forloop_2;
        else goto stof_forloop_1;
}

template <typename type>
string itos(type t, int base = 10, bool showbase = false) {
        string s;
        if (base == 10) s.fmt.dec(1);
        else if (base == 16) s.fmt.hex(1);
        else if (base == 8) s.fmt.oct(1);
        s.fmt.base(showbase);
        s << t;
        return s;
}

template <typename type>
string ftos(type t, bool sci = false) {
        string s;
        s.fmt.sci(sci);
        s << t;
        return s;
}

void die(const char* format, ...);

inline void print(const char* s, FILE* stream = stdout) { fputs(s, stream); }

inline void print(int ch, FILE* stream = stdout) { fputc(ch, stream); fflush(stream); }

int rand(int min = 0, int max = 0);

int rands(unsigned int seed, int min = 0, int max = 0);

char* memrev(char* s, size_t size, size_t n);

char* memrol(char* s, size_t size, size_t n);

char* memror(char* s, size_t size, size_t n);

char* memshl(char* s, size_t size, size_t n);

char* memshr(char* s, size_t size, size_t n);

string chop(const char* str);

string chomp(const char* str, const char* eat = "\r\n");

string cut(const char* str);

string munch(const char* str, const char* eat);

string ltrim(const char* str);

string rtrim(const char* str);

string strip(const char* str);

inline long index(const char* str, const char* find) { return strstr(str, find) - str; }

inline long index(const char* str, int find) { return strchr(str, find) - str; }

inline long length(const char* str) { return strlen(str); }

inline bool eq(const char* s1, const char* s2) { return !strcmp(s1, s2); }

inline bool sfront(const char* s1, const char* s2) { return !strncmp(s1, s2, strlen(s2)); }

inline bool sback(const char* s1, const char* s2) { return !strncmp(s1 + strlen(s1) - strlen(s2), s2, strlen(s2)); }

string substr(const char* str, size_t offset, size_t length);

string lc(const char* str);

string lcfirst(const char* str);

string uc(const char* str);

string ucfirst(const char* str);

inline long dec(const char* str) { return stoi<long>(str, 10); }

inline long bin(const char* str) { return stoi<long>(str, 2); }

inline long oct(const char* str) { return stoi<long>(str, 8); }

inline long hex(const char* str) { return stoi<long>(str, 16); }

long rindex(const char* str, const char* find);

long rindex(const char* str, int find);

unsigned short cksum(const char* buf);

string q(const char* str);

string qq(const char* str);

string qx(const char* exec);

string scat(const char* s1, const char* s2);

string sdup(const char* str, int x);

string tok(size_t index, const char* str, const char* delim = " ");

string tok(size_t index, const char* str, int delim);

long ntok(const char* str, const char* delim = " ");

long ntok(const char* str, int delim);

long itok(size_t index, const char* str, const char* delim = " ");

long itok(size_t index, const char* str, int delim);

std::deque<axcel::string> split(const char* str, const char* delim);

std::deque<axcel::string> split(const char* str, int delim);

string join(std::deque<axcel::string> v, const char* delim = " ");

string join(std::deque<axcel::string> v, int delim);

 
namespace fs {

#ifdef _WIN32

inline bool cd(const char* path) { return SetCurrentDirectoryA(path); }

inline bool rm(const char* fname) { return DeleteFileA(fname); }

inline bool md(const char* path) { return CreateDirectoryA(path, NULL); }
#else

bool cd(const char* path);

bool rm(const char* fname);

bool md(const char* path);
#endif

string gcd();

string ls(const char* dir = 0);

bool creat(const char* fname);

/*bool mkfifo(const char* fname);
bool mkhlnk(const char* ofname, const char* lfname);
bool mkslnk(const char* ofname, const char* lfname);
string rdlnk(const char* lfname);*/

bool trunc(const char* fname, unsigned long len);

bool rd(const char* dir, bool rmsub = 1);

bool cp(const char* src, const char* dst);

bool mv(const char* src, const char* dst);

size_t fsize(const char* fname);

bool fexist(const char* fname);

bool fisdir(const char* fname);

bool fisreg(const char* fname);

string fread(const char* fname, size_t len = 0);

size_t fread(const char* fname, char* buf, size_t len = 0);

data fbread(const char* fname, size_t len = 0);

size_t fbwrite(const char* fname, data d, size_t len = 0);

size_t fwrite(const char* fname, const char* buf, size_t len = 0);

size_t fcat(const char* fname, const char* buf, size_t len = 0);

bool fcmp(const char* src, const char* dst);

timer fatime(const char* fname);

timer fmtime(const char* fname);

string tmpnam();

};

namespace proc {

class thread : virtual public object {
public:
        virtual string type();
        virtual operator string ();
#ifdef _WIN32
        DWORD tid;
#else
        pthread_t tid;
#endif
        size_t stack;
        
        void* (*sub)(void*);
        thread();
        ~thread();
        thread(void* (*tfunc)(void*));
        bool start(void* param = 0);
        bool stop();
        bool join(void ** ret = 0);
        bool tjoin(size_t ms, void ** ret = 0);
        bool getret(void ** retval = 0);
        proc::thread& operator= (void* (*tfunc)(void*));
        proc::thread& operator= (proc::thread t);
        bool operator!= (void* (*tfunc)(void*));
        bool operator!= (proc::thread t);
        bool operator== (void* (*tfunc)(void*));
        bool operator== (proc::thread t);

        static void exit(void* retval);
        static proc::thread self();
private:
#ifdef _WIN32
        HANDLE fd;
#else
        pthread_attr_t attr;
#endif
};

#ifdef _WIN32
inline void delay(size_t ms) { Sleep(ms); }
DWORD run(const char* program, const char* argv = 0, void* envp = 0);
#else
void delay(size_t ms);
pid_t run(const char* program, const char* argv = 0, void* envp = 0);
#endif

string lsproc();

bool killp(size_t pid);

bool killp(const char* name);

bool freeze(size_t pid);

bool freeze(const char* name);

bool cont(size_t pid);

bool cont(const char* name);

bool envset(const char* name, const char* value);

string envget(const char* name);

class library : virtual public object {
public:
        virtual string type();
        virtual operator string ();
#ifdef _WIN32
        HMODULE fd;
#else
        void* fd;
#endif
        library() { fd = 0; }
        ~library();
        library& operator =(const char* libname);
        library& operator= (library s);
        bool operator== (library s);
        bool operator!= (library s);
        void* operator[] (const char* name);
private:
        string libraryname;
};

class mutex : virtual public object {
public:
        virtual string type();
        virtual operator string ();
#ifdef _WIN32
        CRITICAL_SECTION id;
#else
        pthread_mutex_t id;
#endif
        mutex();
        ~mutex();
        void lock();
        bool trylock();
        void unlock();
};

class semaphore : virtual public object {
public:
        virtual string type();
        virtual operator string ();
#ifdef _WIN32
        HANDLE id;
#else
        sem_t* id;
#endif
        bool named;
        semaphore() {}
        semaphore(size_t count);
        semaphore(const char* name);
        ~semaphore();
        bool init(size_t count);
        bool die();
        bool open(const char* name);
        bool close();
        bool get(size_t ms = 0);
        bool tryget();
        bool ret();
private:
#ifndef _WIN32
        char* n;
        sem_t s;
#endif
};

#ifndef _WIN32
sem_t* mksem(const char* name, size_t count);
bool rmsem(const char* name);
#else
HANDLE mksem(const char* name, size_t count);

/* DOES NOTHING! Just for compatability */
inline bool rmsem(const char* name) { return true; }
#endif

class pstream : virtual public io::ios {
private:
        string pname; size_t p;
#ifndef _WIN32
        int wpipe[2]; int rpipe[2];
#else
        HANDLE rin, win, rout, wout, rerr, werr, ph;
#endif
public:

        bool blocking;
        pstream();

        virtual string type();

        virtual operator string ();

        string name();

        int getc();
        int putc(int c);
        
        bool open(const char* program, const char* argv = 0, void* envp = 0);
        bool open(const char* program, const char* argv, environment envp);
        bool open(const char* program, const char* argv, data envp);
        
        void close();
        
        size_t pid();
        operator size_t () { return pid(); }
};

class environment : virtual public object {
private:
        struct p { string k; string v; };
        std::deque<p> e;
public:
        string type();
        operator string ();

        string vars();

        string& operator[] (const char* s);

        string& at(size_t i);

        size_t len();

        environment& clear();

        bool empty();

        data bake();
};

}

namespace net {

namespace irc {

class msg : virtual public object {
public:
        virtual string type();
        virtual operator string ();
        
        string buf;
        msg(const char* line = 0);
        msg& operator= (const char* line);
        bool operator== (const char* line);
        bool operator!= (const char* line);

        string server();
        string nick();
        string user();
        string host();
        string cmd();
        string param(int index);
        string data();
};
/*
class msg : virtual public object {
public:
        virtual string type();
        operator string ();
        msg(const char* line = 0);
        msg& operator= (const char* line);
        msg& operator= (const msg& s);
        bool operator== (const char* line);
        bool operator!= (const char* line);
        bool operator== (msg im);
        bool operator!= (msg im);
        const char* server;
        const char* nick;
        const char* user;
        const char* host;
        const char* cmd;
        const char* param(int index);
        const char* data;
private:
        char buf[536];
};*/

};

namespace http {

data download(const char* url, const char* port = "80");

class query : virtual public axcel::object {
private:
        struct svarpair { string n; string v; };
        std::deque<svarpair> svars;
public:
        string type();
        operator string();
        string buf;
        string vars();
        string& var(const char* v);
        query& operator= (const char* s);
        string& operator[] (const char* v);
        query() {}
        query(const char* s);
        bool operator== (const char* s);
        bool operator== (query q);
        bool operator!= (const char* s);
        bool operator!= (query q);
};

class field : virtual public axcel::object {
private:
        struct svarpair { string n; string v; };
        std::deque<svarpair> svars;
public:
        string type();
        operator string();
        field() {}
        field(const char* s);
        string name;
        string data();
        string vars();
        string& var(const char* v = 0);
        field& operator= (const char* s);
        string& operator[] (const char* v);
        bool operator== (const char* s);
        bool operator== (field f);
        bool operator!= (const char* s);
        bool operator!= (field f);
};

class request : virtual public axcel::object {
public:
        string type();
        operator string ();
        request& operator= (const char* s);
        request() {}
        request(const char* s) { this->operator=(s); }
        string file;
        string qstr;
        string method;
        double ver;
        bool operator== (const char* s);
        bool operator== (request r);
        bool operator!= (const char* s);
        bool operator!= (request r);
};

class response : virtual public axcel::object {
public:
        string type();
        operator string ();
        response& operator= (const char* s);
        response() {}
        response(const char* s) { this->operator=(s); }
        double ver;
        int code;
        string status;
        bool operator== (const char* s);
        bool operator== (response r);
        bool operator!= (const char* s);
        bool operator!= (response r);
};

class header : virtual public axcel::object {
private:
        std::deque<field> f;
public:
        string type();
        operator string ();
        size_t len();
        string vars();
        field& var(const char* s);
        field& operator[] (const char* s);
        field& at(size_t i);
        header& operator= (const char* s);
        header& clear();
        header() {}
        header(const char* s);
        bool operator== (const char* s);
        bool operator== (header h);
        bool operator!= (const char* s);
        bool operator!= (header h);
};

};


};

struct errno_str { int no; const char* str; };
extern struct errno_str errno_strs[];

class exception : virtual public object {
public:

        int no;
        string desc;
        string type();
        operator string();
        //operator int() { return no; }
        //operator bool() { return no; }
        bool operator !() { return !no; }
        exception();
        exception(int number);
        exception(const exception& e);
        exception(const char* msg);
        exception& operator= (int number);
        exception& operator= (const exception e);
        exception& operator= (const char* msg);
        bool operator== (exception e);
        bool operator== (const char* s);
        bool operator== (int num);
        bool operator!= (exception e);
        bool operator!= (const char* s);
        bool operator!= (int num);
};



}

using namespace axcel;

#endif