diff options
Diffstat (limited to 'include/base')
-rw-r--r-- | include/base/coro.h | 7 | ||||
-rw-r--r-- | include/base/error.h | 7 | ||||
-rw-r--r-- | include/base/flate.h | 16 | ||||
-rw-r--r-- | include/base/fmt.h | 73 | ||||
-rw-r--r-- | include/base/fs.h | 29 | ||||
-rw-r--r-- | include/base/gz.h | 29 | ||||
-rw-r--r-- | include/base/io.h | 141 | ||||
-rw-r--r-- | include/base/mem.h | 63 | ||||
-rw-r--r-- | include/base/mmap.h | 13 | ||||
-rw-r--r-- | include/base/rng.h | 9 | ||||
-rw-r--r-- | include/base/sort.h | 18 | ||||
-rw-r--r-- | include/base/string.h | 30 | ||||
-rw-r--r-- | include/base/utf.h | 36 |
13 files changed, 471 insertions, 0 deletions
diff --git a/include/base/coro.h b/include/base/coro.h new file mode 100644 index 0000000..e8f23b1 --- /dev/null +++ b/include/base/coro.h @@ -0,0 +1,7 @@ +#pragma once + +typedef struct Coro Coro; + +Coro* coro·make(uintptr stk, uintptr (*func)(Coro*, uintptr)); +uintptr coro·yield(Coro *c, uintptr arg); +int coro·free(Coro *c); diff --git a/include/base/error.h b/include/base/error.h new file mode 100644 index 0000000..57c1a77 --- /dev/null +++ b/include/base/error.h @@ -0,0 +1,7 @@ +#pragma once + +void exits(char *s); +void errorf(byte* fmt, ...); +void verrorf(byte* fmt, va_list args); +void panicf(byte *fmt, ...); +void vpanicf(byte *fmt, va_list args); diff --git a/include/base/flate.h b/include/base/flate.h new file mode 100644 index 0000000..670c8e7 --- /dev/null +++ b/include/base/flate.h @@ -0,0 +1,16 @@ +#pragma once + +// ----------------------------------------------------------------------------- +// libflate +// NOTE: Experimental! + +typedef struct flate·Reader flate·Reader; +typedef struct flate·Writer flate·Writer; + +flate·Reader *flate·openreader(io·Reader rdr, void* r, mem·Allocator mem, void* m); +int flate·read(flate·Reader *rdr, int sz, int n, void *buf); +int flate·closereader(flate·Reader *rdr); + +flate·Writer *flate·openwriter(io·Writer wtr, void* w, mem·Allocator mem, void* m); +int flate·write(flate·Writer *wtr, int sz, int n, void *buf); +int flate·closewriter(flate·Writer *wtr); diff --git a/include/base/fmt.h b/include/base/fmt.h new file mode 100644 index 0000000..4c187fd --- /dev/null +++ b/include/base/fmt.h @@ -0,0 +1,73 @@ +#pragma once + +typedef struct fmt·State fmt·State; + +struct fmt·State +{ + struct{ + char *beg; + char *cur; + char *end; + } buffer; + int n; + + va_list args; + rune verb; + ulong flag; + int width; + int prec; + char *thousands, *groups, *decimal; + + void *file; + int (*flush)(fmt·State *); + struct { + void *heap; + mem·Reallocator mem; + }; +}; + +#define iota(x) (1 << (x)) +enum +{ + fmt·Width = iota(0), + fmt·Left = iota(1), + fmt·Prec = iota(2), + fmt·Sharp = iota(3), + fmt·Space = iota(4), + fmt·Sign = iota(5), + fmt·Apost = iota(6), + fmt·Zero = iota(7), + fmt·Unsigned = iota(8), + fmt·Short = iota(9), + fmt·Long = iota(10), + fmt·Vlong = iota(11), + fmt·Comma = iota(12), + fmt·Byte = iota(13), + fmt·Ldouble = iota(14), + fmt·Flag = iota(15), +}; +#undef iota + +/* normal printing interface */ +int fmt·print(char *fmt, ...); +int fmt·fprint(int fd, char *fmt, ...); +void fmt·panic(char *fmt, ...); + +int fmt·sprint(char *buf, char *fmt, ...); +int fmt·nsprint(int len, char *buf, char *fmt, ...); +char *fmt·esprint(char *buf, char *end, char *fmt, ...); + +int fmt·vprint(char *fmt, va_list args); +int fmt·vfprint(int fd, char *fmt, va_list args); +int fmt·vnsprint(int len, char *buf, char *fmt, va_list args); +char *fmt·vesprint(char *buf, char *end, char *fmt, va_list args); + +/* low-level interface: used for custom printing verbs */ +int fmt·open(int fd, int len, char *buf, fmt·State *); // creates a buffer on a file +int fmt·make(mem·Reallocator mem, void *heap, fmt·State *); // creates an in-memory buffer +void fmt·free(fmt·State *); // releases an in-memory buffer + +int fmt·do(fmt·State *, char *fmt); +int fmt·write(fmt·State *, char *fmt, ...); +int fmt·vwrite(fmt·State *, char *fmt, va_list args); +int fmt·install(int c, int (*format)(fmt·State *)); diff --git a/include/base/fs.h b/include/base/fs.h new file mode 100644 index 0000000..6852a84 --- /dev/null +++ b/include/base/fs.h @@ -0,0 +1,29 @@ +#pragma once + +#define iota(x) 1 << (x) +enum +{ + fs·preorder = iota(0), + fs·nolinks = iota(1), + fs·verbose = iota(2), +}; +#undef iota + +typedef struct fs·Walker fs·Walker; +typedef struct fs·History fs·History; + +struct fs·Walker +{ + int fd, lev, max, err; + uchar flags : 4; + fs·History *hist; + struct { + void *data; + int (*func)(void *data, char *relp, char *absp, io·Stat* info); + }; + char *base, *end, path[4096]; +}; + +int fs·init(fs·Walker *, char *path); +void fs·fini(fs·Walker *); +void fs·walk(fs·Walker *); diff --git a/include/base/gz.h b/include/base/gz.h new file mode 100644 index 0000000..3b3a830 --- /dev/null +++ b/include/base/gz.h @@ -0,0 +1,29 @@ +#pragma once + +typedef void gz·Stream; + +/* interfaces */ +extern io·Reader gz·Reader; +extern io·Peeker gz·Peeker; +extern io·Seeker gz·Seeker; +extern io·SeekReader gz·SeekReader; +extern io·PeekReader gz·PeekReader; + +extern io·Writer gz·Writer; +extern io·Putter gz·Putter; +extern io·PutWriter gz·PutWriter; +extern io·ReadWriter gz·ReadWriter; + +gz·Stream *gz·open(byte *path, byte *mode); +int gz·close(gz·Stream* s); +int gz·read(gz·Stream *s, int sz, int n, void* buf); +int gz·readln(gz·Stream *s, int n, byte *buf); +byte gz·getbyte(gz·Stream *s); +int gz·ungetbyte(gz·Stream *s, byte c); +int gz·write(gz·Stream *s, int sz, int n, void* buf); +int gz·putbyte(gz·Stream *s, byte str); +int gz·putstring(gz·Stream *s, byte *str); +int gz·printf(gz·Stream *s, byte *fmt, ...); +int gz·flush(gz·Stream *s); +int gz·seek(gz·Stream *s, long off, enum SeekPos whence); +long gz·tell(gz·Stream *s); diff --git a/include/base/io.h b/include/base/io.h new file mode 100644 index 0000000..f8c0bcc --- /dev/null +++ b/include/base/io.h @@ -0,0 +1,141 @@ +#pragma once + +enum SeekPos +{ + seek·cur = SEEK_CUR, + seek·set = SEEK_SET, + seek·end = SEEK_END +}; + +typedef struct io·Reader +{ + int (*read)(void*, int sz, int n, void *buf); +} io·Reader; +extern io·Reader sys·Reader; + +typedef struct io·Peeker +{ + byte (*get)(void*); + int (*unget)(void*, byte); +} io·Peeker; +extern io·Peeker sys·Peeker; + +typedef struct io·Seeker +{ + int (*seek)(void *skr, long off, enum SeekPos whence); + long (*tell)(void *skr); +} io·Seeker; +extern io·Seeker sys·Seeker; + +typedef struct io·SeekReader +{ + io·Seeker; + io·Reader; +} io·SeekReader; +extern io·SeekReader sys·SeekReader; + +typedef struct io·PeekReader +{ + io·Reader; + io·Peeker; +} io·PeekReader; +extern io·PeekReader sys·PeekReader; + +typedef struct io·Writer +{ + int (*write)(void*, int sz, int n, void *buf); +} io·Writer; +extern io·Writer sys·Writer; + +typedef struct io·Putter +{ + int (*put) (void*, byte); + int (*puts)(void*, string); +} io·Putter; +extern io·Putter sys·Putter; + +typedef struct io·PutWriter +{ + io·Writer; + io·Putter; +} io·PutWriter; +extern io·PutWriter sys·PutWriter; + +typedef struct io·ReadWriter +{ + io·Reader; + io·Writer; +} io·ReadWriter; +extern io·ReadWriter sys·ReadWriter; + +/* XXX: change casing */ +enum +{ + ReadOK = R_OK, + WriteOK = W_OK, + ExecOK = X_OK, +}; + +/* XXX(deprecated): file handling */ + +typedef FILE io·Stream; +typedef struct stat io·Stat; + +io·Stream *io·open(byte *name, byte *mode); +int io·fd(io·Stream *s); +int io·stat(io·Stream *s, io·Stat *buf); +int io·close(io·Stream *s); +byte io·getbyte(io·Stream *s); +int io·ungetbyte(io·Stream *s, byte c); +int io·read(io·Stream *s, int sz, int n, void *buf); +int io·readln(io·Stream *s, int n, byte *buf); +int io·putbyte(io·Stream *s, byte c); +int io·putstring(io·Stream *s, string str); +int io·write(io·Stream *s, int sz, int n, void *buf); +int io·flush(io·Stream *s); +int io·seek(io·Stream *s, long off, enum SeekPos whence); +long io·tell(io·Stream *s); + +/* basic os helpers */ + +int os·exists(byte *path, int flag); +byte *os·dirname(byte *path); +byte *os·basename(byte *path); +int os·sep(void); + +/* io interfaces */ +/* buffered i/o */ +typedef struct io·Buffer io·Buffer; + +enum +{ + bufio·size = 2*4096, + bufio·ungets = 8, + bufio·eof = -1, + bufio·err = -2, + + bufio·nil = 1 << 0, + bufio·rdr = 1 << 1, + bufio·wtr = 1 << 2, + bufio·end = 1 << 3, +}; + +struct io·Buffer +{ + int state; + int runesize; + void *h; + union { + io·Reader rdr; + io·Writer wtr; + }; + vlong size; + byte *beg, *pos, *end; + byte buf[bufio·size + bufio·ungets]; +}; + +int bufio·initreader(io·Buffer *buf, io·Reader rdr, void *h); +void bufio·finireader(io·Buffer *buf); +int bufio·getbyte(io·Buffer *buf); +int bufio·ungetbyte(io·Buffer *buf, byte c); +int bufio·read(io·Buffer *buf, int sz, int n, void *out); diff --git a/include/base/mem.h b/include/base/mem.h new file mode 100644 index 0000000..3f1b6e1 --- /dev/null +++ b/include/base/mem.h @@ -0,0 +1,63 @@ +#pragma once + +// ---------------------------------------------------------------------------- +// dynamic array + +typedef struct BufHdr +{ + vlong len; + vlong cap; + byte buf[]; +} BufHdr; + +#define bufhdr(b) ((BufHdr*)((uint8*)(b)-offsetof(BufHdr, buf))) +#define buflen(b) ((b) ? (bufhdr(b)->len) : 0) +#define bufcap(b) ((b) ? (bufhdr(b)->cap) : 0) +#define bufend(b) ((b) + buflen(b)) +#define bufsize(b) ((b) ? (buflen(b) * sizeof((b)[0])) : 0) + +#define buffree(b) ((b) ? (free(bufhdr(b)), (b) = nil) : 0) +#define buffit(b, n) ((n) <= bufcap(b) ? 0 : ((b) = ·bufgrow((b), (n), sizeof(*(b))))) + +#define bufpush(b, ...) (buffit((b), 1 + buflen(b)), (b)[bufhdr(b)->len++] = (__VA_ARGS__)) +#define bufaddn(b, n) (buffit(b, buflen(b)+n), bufhdr(b)->len += n, b+bufhdr(b)->len-n) + +#define bufpop(b) ((b)[--bufhdr(b)->len]) +#define bufdel(b, i) bufdeln((b), (i), 1) +#define bufdeln(b, i, n) (memmove((b)+(i), (b)+(i)+(n), sizeof(*(b))*(bufhdr(b)->len-(n)-(i)), bufhdr(b)->len -= (n)) +#define bufdelswap(b, i) ((b)[i] = bufend(b)[-1], bufhdr(b)->len-=1) + +void* ·bufgrow(void*, vlong, vlong); + +// ----------------------------------------------------------------------------- +// memory allocation + +/* allocator interface */ +typedef struct mem·Allocator { + void *(*alloc)(void *heap, uint n, ulong size); + void (*free)(void *heap, void *ptr); +} mem·Allocator; + +extern mem·Allocator sys·Memory; + +typedef struct mem·Reallocator { + void *(*alloc)(void *iface, uint n, ulong size); + void *(*realloc)(void *iface, void *ptr, uint n, ulong size); + void (*free)(void *iface, void *ptr); +} mem·Reallocator; + +extern mem·Reallocator sys·FullMemory; + +/* simple memory arena */ +typedef struct mem·Arena mem·Arena; + +mem·Arena *mem·makearena(mem·Allocator from, void*); +void *mem·arenaalloc(mem·Arena *A, uint n, ulong size); +void mem·freearena(mem·Arena *A); + +extern mem·Allocator mem·ArenaAllocator; + +/* generalized memxxx functions */ +void memset64(void *dst, uint64 val, uintptr size); + + diff --git a/include/base/mmap.h b/include/base/mmap.h new file mode 100644 index 0000000..9c4bd5f --- /dev/null +++ b/include/base/mmap.h @@ -0,0 +1,13 @@ +#pragma once + +typedef struct mmap·Reader +{ + vlong len; + union{ + char *b; + uchar *u; + }; +} mmap·Reader; + +mmap·Reader mmap·open(byte *name); +int mmap·close(mmap·Reader rdr); diff --git a/include/base/rng.h b/include/base/rng.h new file mode 100644 index 0000000..ee41509 --- /dev/null +++ b/include/base/rng.h @@ -0,0 +1,9 @@ +#pragma once + +int rng·init(uint64 seed); +double rng·random(void); +double rng·exponential(double lambda); +bool rng·bernoulli(double f); +double rng·normal(void); +uint64 rng·randi(int max); +uint64 rng·poisson(double mean); diff --git a/include/base/sort.h b/include/base/sort.h new file mode 100644 index 0000000..e9a0e87 --- /dev/null +++ b/include/base/sort.h @@ -0,0 +1,18 @@ +#pragma once + +void sort·int(uintptr n, int arr[]); +void sort·int8(uintptr n, int8 arr[]); +void sort·int16(uintptr n, int16 arr[]); +void sort·int32(uintptr n, int32 arr[]); +void sort·int64(uintptr n, int64 arr[]); + +void sort·uint(uintptr n, uint arr[]); +void sort·uint8(uintptr n, uint8 arr[]); +void sort·uint16(uintptr n, uint16 arr[]); +void sort·uint32(uintptr n, uint32 arr[]); +void sort·uint64(uintptr n, uint64 arr[]); + +void sort·float(uintptr n, float arr[]); +void sort·double(uintptr n, double arr[]); + +void sort·string(uintptr n, byte* arr[]); diff --git a/include/base/string.h b/include/base/string.h new file mode 100644 index 0000000..08466fa --- /dev/null +++ b/include/base/string.h @@ -0,0 +1,30 @@ +#pragma once + +typedef byte* string; + +/* augmented string functions */ +string str·makecap(const char *s, vlong len, vlong cap); +string str·makelen(const char *s, vlong len); +string str·make(const char *s); +string str·makef(const char *fmt, ...); +void str·free(string s); +int str·len(const string s); +int str·cap(const string s); +void str·clear(string *s); +void str·grow(string *s, vlong delta); +void str·fit(string *s); +int str·appendlen(string *s, vlong len, const char *b); +int str·append(string *s, const char *b); +int str·appendf(string *s, const char *fmt, ...); +int str·appendbyte(string *s, const char b); +bool str·equals(const string s, const string t); +int str·find(string s, const char* substr); +void str·lower(string s); +void str·upper(string s); +int str·read(string s, int size, int n, void *buf); +void str·replace(string s, const byte* from, const byte* to); +string* str·split(string s, const byte* tok); +string str·join(vlong len, byte** fields, const byte* sep); + +/* raw C string functions */ +char *str·copyn(char *dst, char *src, int n); diff --git a/include/base/utf.h b/include/base/utf.h new file mode 100644 index 0000000..846296c --- /dev/null +++ b/include/base/utf.h @@ -0,0 +1,36 @@ +#pragma once + +#define UTFmax 4 +#define RuneErr 0xFFFDu +#define RuneMax 0x10FFFFu + +#define utf8·onebyte(c) (((c)&0x80u)==0x00u) +#define utf8·twobyte(c) (((c)&0xE0u)==0xC0u) +#define utf8·threebyte(c) (((c)&0xF0u)==0xE0u) +#define utf8·fourbyte(c) (((c)&0xF8u)==0xF0u) + +/* + * UTF-8 functions. + */ +int utf8·len(char *s); // returns number of runes for s +int utf8·runelen(rune r); // returns number of bytes for rune +int utf8·runewidth(rune r); // returns number of printed columns for rune + +int utf8·decode(char *, rune *); // decode 1 rune from char stream, store into rune, return number of bytes +int utf8·encode(rune *, char *); // encode 1 rune from rune stream, store into char, return number of bytes +int utf8·decodeprev(char *s, rune *r); // decode 1 rune from char stream, reading backwards, store into rune, return number of bytes + +char *utf8·find(char *s, rune); // find rune in char stream +char *utf8·findlast(char* s, rune); // find last rune in char stream + +int utf8·canfit(char *, int); // XXX: odd function... + +int utf8·isalpha(rune r); +int utf8·isdigit(rune r); +int utf8·isspace(rune r); +int utf8·istitle(rune r); +int utf8·ispunct(rune r); + +rune utf8·toupper(rune r); +rune utf8·tolower(rune r); +rune utf8·totitle(rune r); |