From 1d188c4f816fce8728fdffaa7ad6ef205ca05abd Mon Sep 17 00:00:00 2001 From: Nicholas Noll Date: Fri, 17 Apr 2020 18:50:29 -0700 Subject: chore: update naming & calling conventions --- Makefile | 7 ++-- README.md | 1 + include/str.h | 62 ++++++++++++++--------------- include/u.h | 9 +++++ rules.mk | 3 ++ src/coro.c | 20 +++++----- src/rules.mk | 5 ++- src/string.c | 125 ++++++++++++++++++++++++++++++---------------------------- 8 files changed, 127 insertions(+), 105 deletions(-) diff --git a/Makefile b/Makefile index 65eb8b5..9c1307b 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ # Compiler, Linker, and Assembler -CC := clang -AR := ar -ASMR := nasm +CC := clang +AR := ar +AS := nasm # All needed build directories INC_DIR := include @@ -23,6 +23,7 @@ TGTLIBS := COMPILE = $(CC) -MMD $(CFLAGS) $(TGTFLAGS) $(INCS) $(TGTINCS) -o $@ -c $< LINK = $(CC) -MMD $(CFLAGS) $(TGTFLAGS) -o $@ $^ $(LIBS) $(TGTLIBS) COMPLINK = $(CC) -MMD $(CFLAGS) $(TGTFLAGS) $(INCS) $(TGTINCS) -o $@ $< $(LIBS) +ASSEMBLE = $(AS) $(AFLAGS) $(TGTFLAGS) -o $@ $< ARCHIVE = $(AR) -crs $@ $^ include rules.mk diff --git a/README.md b/README.md index dec4170..e55ec04 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ - A modern C compiler that accepts UTF-8 identifier names - Make +- Nasm #### Build diff --git a/include/str.h b/include/str.h index c728bf0..85051e4 100644 --- a/include/str.h +++ b/include/str.h @@ -25,38 +25,38 @@ enum RuneMax = 0x10FFFF, }; -int utf8·FullRune(byte* s, int n); -byte *utf8·FindRune(byte* s, long i); -int utf8·CharToRune(Rune *r, byte* s); -int utf8·RuneToChar(byte* s, Rune* r); -int utf8·Len(byte* s); -int utf8·RuneLen(Rune r); -int utf8·IsLetter(Rune r); -int utf8·IsDigit(Rune r); -int utf8·IsSpace(Rune r); -int utf8·IsTitle(Rune r); +int utf8·fullRune(byte *s, int n); +byte *utf8·findRune(byte *s, long i); +int utf8·charToRune(Rune *r, byte *s); +int utf8·runeToChar(byte *s, Rune *r); +int utf8·len(byte *s); +int utf8·runeLen(Rune r); +int utf8·isLetter(Rune r); +int utf8·isDigit(Rune r); +int utf8·isSpace(Rune r); +int utf8·isTitle(Rune r); // ------------------------------------------------------------------------- // Dynamic string functions -string str·NewCap(const byte* s, vlong len, vlong cap); -string str·NewLen(const byte* s, vlong len); -string str·New(const byte* s); -string str·Newf(const byte* fmt, ...); -void str·Free(string s); -int str·Len(const string s); -int str·Cap(const string s); -string str·Clear(string s); -string str·Grow(string s, vlong delta); -string str·Fit(string s); -string str·AppendCount(string s, const byte* b, vlong len); -string str·Append(string s, const byte* b); -string str·Appendf(string s, const byte* fmt, ...); -string str·AppendByte(string s, const byte b); -bool str·Equals(const string s, const string t); -int str·Find(string s, const byte* substr); -void str·Lower(string s); -void str·Upper(string s); -void str·Replace(string s, const byte* from, const byte* to); -string* str·Split(string s, const byte* tok); -string str·Join(byte** fields, vlong numFields, const byte* sep); +string str·newCap(const byte *s, vlong len, vlong cap); +string str·newLen(const byte *s, vlong len); +string str·new(const byte *s); +string str·newf(const byte *fmt, ...); +void str·free(string s); +int str·len(const string s); +int str·cap(const string s); +string str·clear(string s); +string str·grow(string s, vlong delta); +string str·fit(string s); +string str·appendCount(string s, vlong len, const byte *b); +string str·append(string s, const byte* b); +string str·appendf(string s, const byte* fmt, ...); +string str·appendByte(string s, const byte b); +bool str·equals(const string s, const string t); +int str·find(string s, const byte* substr); +void str·lower(string s); +void str·upper(string s); +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); diff --git a/include/u.h b/include/u.h index 349a236..b7bd9ca 100644 --- a/include/u.h +++ b/include/u.h @@ -85,6 +85,15 @@ typedef struct bufHdr void* bufgrow(void*, vlong, vlong); void _bufpop(void*, int, vlong); +// ----------------------------------------------------------------------------- +// Co-routines + +typedef struct coro coro; + +coro* coro·new(uintptr stk, uintptr (*func)(coro* c, uintptr)); +uintptr coro·yield(coro* c, uintptr arg); +error coro·free(coro* c); + // ----------------------------------------------------------------------------- // Strings diff --git a/rules.mk b/rules.mk index cc495d6..7a0d8b6 100644 --- a/rules.mk +++ b/rules.mk @@ -25,6 +25,9 @@ include $(DIR)/rules.mk $(OBJ_DIR)/%.o: $(SRC_DIR)/%.c $(COMPILE) +$(OBJ_DIR)/%.o: $(SRC_DIR)/%.s + $(ASSEMBLE) + %: %.o $(LINK) diff --git a/src/coro.c b/src/coro.c index 4e651d3..82ef4f4 100644 --- a/src/coro.c +++ b/src/coro.c @@ -6,7 +6,7 @@ extern void _newcoro(coro *co, uintptr (*func)(coro*, uintptr), void *stk); extern uintptr _coroyield(coro *co, uintptr arg); -struct coro +struct coro { void* sp; void* bp; @@ -15,9 +15,10 @@ struct coro }; coro* -coro·New(uintptr stk, uintptr (*func)(coro*, uintptr)) +coro·new(uintptr stk, uintptr (*func)(coro*, uintptr)) { - if (!func) return nil; + if (!func) + return nil; if (stk == 0) stk = 8192; @@ -31,26 +32,27 @@ coro·New(uintptr stk, uintptr (*func)(coro*, uintptr)) } error -coro·Free(coro *co) +coro·free(coro *co) { - enum + enum { - GOOD, NIL, + GOOD, EMPTY, LOST, }; - if (!co) return NIL; - if (!co->bp) return LOST; + if (!co) return NIL; + if (!co->bp) return LOST; if (co->size == 0) return EMPTY; free(co->bp); + return GOOD; } uintptr -coro·Yield(coro *c, uintptr arg) +coro·yield(coro *c, uintptr arg) { return _coroyield(c, arg); } diff --git a/src/rules.mk b/src/rules.mk index 2a13bff..ef9b36c 100644 --- a/src/rules.mk +++ b/src/rules.mk @@ -8,7 +8,10 @@ d := $(DIR) # Local variables SRCS_$(d) := $(wildcard $(d)/*.c) -OBJS_$(d) := $(patsubst $(SRC_DIR)/%, $(OBJ_DIR)/%, $(SRCS_$(d):.c=.o)) +ASMS_$(d) := $(wildcard $(d)/*.s) +OBJS_$(d) := $(SRCS_$(d):.c=.o) +OBJS_$(d) += $(ASMS_$(d):.s=.o) +OBJS_$(d) := $(patsubst $(SRC_DIR)/%, $(OBJ_DIR)/%, $(OBJS_$(d))) DEPS_$(d) := $(OBJS_$(d):.o=.d) OBJS := $(OBJS) $(OBJS_$(d)) diff --git a/src/string.c b/src/string.c index d46f0c0..5e66282 100644 --- a/src/string.c +++ b/src/string.c @@ -26,7 +26,7 @@ enum }; int -utf8·CharToRune(Rune* r, byte* s) +utf8·charToRune(Rune* r, byte* s) { int c[UTFmax], i; Rune l; @@ -64,7 +64,7 @@ bad: } int -utf8·RuneToChar(byte* s, Rune* r) +utf8·runeToChar(byte* s, Rune* r) { int i, j; Rune c; @@ -94,14 +94,14 @@ utf8·RuneToChar(byte* s, Rune* r) } int -utf8·RuneLen(Rune r) +utf8·runeLen(Rune r) { byte s[10]; - return utf8·RuneToChar(s, &r); + return utf8·runeToChar(s, &r); } int -utf8·FullRune(byte* s, int n) +utf8·fullRune(byte* s, int n) { int i; Rune c; @@ -118,7 +118,7 @@ utf8·FullRune(byte* s, int n) } byte* -utf8·FindRune(byte* s, long c) +utf8·findRune(byte* s, long c) { long c1; Rune r; @@ -134,7 +134,7 @@ utf8·FindRune(byte* s, long c) s++; continue; } - n = utf8·CharToRune(&r, s); + n = utf8·charToRune(&r, s); if (r == c) return s; s += n; } @@ -155,7 +155,7 @@ utf8·FindRune(byte* s, long c) // len defines the length of the C substring that we will copy into our buffer. // The backing buffer will have capacity cap. string -str·NewCap(const byte* s, vlong len, vlong cap) +str·newCap(const byte* s, vlong len, vlong cap) { struct str·Hdr* h; @@ -184,34 +184,34 @@ cleanup: // New returns a new dynamic string object, initialized from the given C string. // The backing buffer capacity is equivalent to the string length. string -str·NewLen(const byte* s, vlong len) +str·newLen(const byte* s, vlong len) { vlong sl = (s == nil) ? 0 : strlen(s); if (sl < len) panicf("attempted to take a bigger substring than string length"); vlong cap = (len == 0) ? 1 : len; - return str·NewCap(s, len, cap); + return str·newCap(s, len, cap); } // New returns a new dynamic string object, initialized from the given C string. // The backing buffer capacity is equivalent to the string length. string -str·New(const byte* s) +str·new(const byte* s) { vlong len = (s == nil) ? 0 : strlen(s); - return str·NewLen(s, len); + return str·newLen(s, len); } // Newf returns a new dynamic string object string -str·Newf(const byte* fmt, ...) +str·newf(const byte* fmt, ...) { va_list args; va_start(args, fmt); vlong n = vsnprintf(nil, 0, fmt, args); va_end(args); - string s = str·NewCap(nil, 0, n); + string s = str·newCap(nil, 0, n); va_start(args, fmt); vsnprintf(s, n + 1, fmt, args); @@ -225,14 +225,14 @@ str·Newf(const byte* fmt, ...) // Free returns memory associated to the buffer. void -str·Free(string s) +str·free(string s) { free(s - sizeof(str·Hdr)); } // Len returns the length of the string. int -str·Len(const string s) +str·len(const string s) { str·Hdr* h = (str·Hdr*)(s - sizeof(str·Hdr)); return h->len; @@ -240,14 +240,14 @@ str·Len(const string s) // Cap returns the capacity of the string buffer. int -str·Cap(const string s) +str·cap(const string s) { str·Hdr* h = (str·Hdr*)(s - sizeof(str·Hdr)); return h->cap; } string -str·Clear(string s) +str·clear(string s) { str·Hdr* h = (str·Hdr*)(s - sizeof(str·Hdr)); h->len = 0; @@ -260,11 +260,11 @@ str·Clear(string s) // If it already can, this is a NO OP. // If it can't, the string will be reallocated. string -str·Grow(string s, vlong delta) +str·grow(string s, vlong delta) { str·Hdr *h, *newh; - vlong cap = str·Cap(s); - vlong len = str·Len(s); + vlong cap = str·cap(s); + vlong len = str·len(s); Assert(cap >= len); // To prevent unsigned behavior if (cap - len >= delta) return s; @@ -292,11 +292,11 @@ str·Grow(string s, vlong delta) // buffer. If the capacity equals the length, then the function is a NOOP. The // byte array is unchanged. string -str·Fit(string s) +str·fit(string s) { str·Hdr* h; - vlong cap = str·Cap(s); - vlong len = str·Len(s); + vlong cap = str·cap(s); + vlong len = str·len(s); if (cap == len) return s; @@ -312,17 +312,17 @@ str·Fit(string s) // string to our buffer. The result is reallocated if not enough room is present // in the buffer. string -str·AppendCount(string s, const byte* b, vlong n) +str·appendCount(string s, vlong n, const byte* b) { vlong bl = strlen(b); if (n > bl) panicf("attempted to make a substring longer than string"); - s = str·Grow(s, n); + s = str·grow(s, n); if (s == nil) return nil; str·Hdr* h = (str·Hdr*)(s - sizeof(str·Hdr)); - memcpy(s + str·Len(s), b, n); + memcpy(s + str·len(s), b, n); h->len += n; s[h->len] = '\0'; @@ -332,23 +332,23 @@ str·AppendCount(string s, const byte* b, vlong n) // Append will append the given null terminated C string to the string data // structure. This variant will append the entire string. string -str·Append(string s, const byte* b) +str·append(string s, const byte* b) { - return str·AppendCount(s, b, strlen(b)); + return str·appendCount(s, strlen(b), b); } // AppendByte will append the given byte to our string. // NOTE: As the byte is on the stack, it is not null-terminated. // Can not pass to the above functions. string -str·AppendByte(string s, const byte b) +str·appendByte(string s, const byte b) { - s = str·Grow(s, 1); + s = str·grow(s, 1); if (s == nil) return nil; str·Hdr* h = (str·Hdr*)(s - sizeof(str·Hdr)); - *(s + str·Len(s)) = b; + *(s + str·len(s)) = b; h->len++; s[h->len] = '\0'; // NOTE: I don't think an explicit zero is required..? @@ -357,35 +357,38 @@ str·AppendByte(string s, const byte b) // Equals returns true if string s and t are equivalent. bool -str·Equals(const string s, const string t) +str·equals(const string s, const string t) { - vlong sL = str·Len(s); - vlong tL = str·Len(t); + vlong sL = str·len(s); + vlong tL = str·len(t); if (sL != tL) return false; return memcmp(s, t, sL) == 0; } -// Utility Methods ------------------------------------ -// -// Appendf will append the given formatted string to our buffer. -// Returns the newly minted string. +//------------------------------------------------------------------------ +// Utility Methods + +/* + * Appendf will append the given formatted string to our buffer. + * Returns the newly minted string + */ string -str·Appendf(string s, const byte* fmt, ...) +str·appendf(string s, const byte* fmt, ...) { va_list args; va_start(args, fmt); - int remain = str·Cap(s) - str·Len(s); - int n = vsnprintf(s + str·Len(s), remain + 1, fmt, args); + int remain = str·cap(s) - str·len(s); + int n = vsnprintf(s + str·len(s), remain + 1, fmt, args); va_end(args); if (n > remain) { // If the first write was incomplete, we overwite the data again. - s = str·Grow(s, n); + s = str·grow(s, n); va_list args; va_start(args, fmt); - n = vsnprintf(s + str·Len(s), n + 1, fmt, args); - Assert(n - remain <= str·Cap(s)); + n = vsnprintf(s + str·len(s), n + 1, fmt, args); + Assert(n - remain <= str·cap(s)); va_end(args); } @@ -398,7 +401,7 @@ str·Appendf(string s, const byte* fmt, ...) // Find will find the first occurence of // substr in the string Returns -1 if nothing was found. int -str·Find(string s, const byte* substr) +str·find(string s, const byte* substr) { byte* loc = strstr(s, substr); if (loc == nil) return -1; @@ -412,18 +415,18 @@ str·Lower(string s) { byte *b, *e; b = s; - e = b + str·Len(s); + e = b + str·len(s); while (b++ != e) *b = tolower(*b); } // Upper will force all runes in the string to be uppercase. void -str·Upper(string s) +str·upper(string s) { byte *b, *e; b = s; - e = b + str·Len(s); + e = b + str·len(s); while (b++ != e) *b = toupper(*b); } @@ -432,13 +435,13 @@ str·Upper(string s) // Edits are done in place and modify the string. // NOTE: As of now strings from and to must be the same size. void -str·Replace(string s, const byte* from, const byte* to) +str·replace(string s, const byte* from, const byte* to) { vlong fromL = strlen(from); vlong toL = strlen(to); if (toL != fromL) { panicf("different sized replacement string not supported"); } - vlong l = str·Len(s); + vlong l = str·len(s); vlong i = l; vlong j = l; @@ -456,12 +459,12 @@ str·Replace(string s, const byte* from, const byte* to) // Returns a stretchy buffer of strings that result from the partition. // It is the caller's responsibility to clean the memory. string* -str·Split(string s, const byte* tok) +str·split(string s, const byte* tok) { string* fields = nil; vlong start = 0; - vlong sL = str·Len(s); + vlong sL = str·len(s); vlong tokL = strlen(tok); if (sL == 0 || tokL == 0) return nil; @@ -469,7 +472,7 @@ str·Split(string s, const byte* tok) for (vlong i = 0; i < sL - tokL; i++) { if ((tokL == 1 && s[i] == tokL) || !memcmp(s + i, tok, tokL)) { - bufpush(fields, str·NewLen(s + start, i - start)); + bufpush(fields, str·newLen(s + start, i - start)); if (fields[buflen(fields) - 1] == nil) goto cleanup; start = i + tokL; @@ -477,27 +480,27 @@ str·Split(string s, const byte* tok) } } - bufpush(fields, str·NewLen(s + start, sL - start)); + bufpush(fields, str·newLen(s + start, sL - start)); return fields; cleanup: for (vlong i = 0; i < buflen(fields); i++) { - str·Free(fields[i]); + str·free(fields[i]); } buffree(fields); return nil; } string -str·Join(byte** fields, vlong numFields, const byte* sep) +str·join(vlong len, byte** fields, const byte* sep) { - string s = str·NewCap(nil, 0, 10); + string s = str·newCap(nil, 0, 10); int j = 0; - for (j = 0; j < numFields; j++) { - s = str·Append(s, fields[j]); - if (j < numFields - 1) { s = str·AppendCount(s, sep, 1); } + for (j = 0; j < len; j++) { + s = str·append(s, fields[j]); + if (j < len - 1) { s = str·appendCount(s, 1, sep); } } return s; -- cgit v1.2.1