lily-org/lily
3
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

saving

Browse source
This commit is contained in:
koniifer 2025-03-08 16:53:24 +00:00
parent b72db1ce44
commit 01ea41bc34
54 changed files with 127 additions and 2979 deletions

2
.gitignore vendored
View file

@ -1 +1 @@
/target/
out/

51
README.md
View file

@ -1,54 +1,5 @@
# Lily
an attempt at a cross-platform standard library for hblang.
> [!CAUTION]
> # hblang is currently very broken
> like super broken. please don't use lily right now.<br>
> hblang is getting rewritten in zig, so soon we will have this all working again.
> [!IMPORTANT]
> all features, targets, modules, etc, are provisional and may be subject to change or deletion
use `./build -h` to see available arguments.
### supports:
- changing target
- custom linker (for native targets)
- running the executable (for native targets)
- setting output path
- dumping assembly representation
- only recompiling if either source or environment change
### To change build target
use the `-t` flag supplied in `./build`
use a target triple (i.e. `x86_64-unknown-linux-gnu`), or pick from one of these aliases:
>[!NOTE]
`hbvm == ableos` (for now)
>- hbvm
>- ableos
>- libc (links to system libc)
### Modifying build config
compiler flags are in: `./build` (at top of file)
> used for NON-CODE configuration
compile-time configuration is in: `./src/lily/lib.hb`
> used for things like toggling debug assertions, setting minimum log level, etc
# Features
features include:
- heap allocator
- system rand
- memory operations
- math operations
- string operations, including split iteration
- hasher
- hashmap
- vec (dynamic array)
- printing & logging
- result type
- typesystem wrapper
- string formatting & interpolation
> all features, targets, modules, etc, are provisional and may be subject to change or deletion

17
TODO.md
View file

@ -1,17 +0,0 @@
- seeded prng
- smarter allocator for alloc
- add code comments everywhere
- add docstrings everywhere
- write more of spec & docs
- optimise hashmap implementation
- rehash buckets & squash after size threshold
- write test suite
- report compiler bugs
- once done, verify i have written ok code ૮꒰ ˶• ༝ •˶꒱ა
- make foldhash implementation identical to original
- report MORE compiler bugs!!!
- implement more math stuff
- utilise libc more where possible (free performance, portability, reliability)
- optimise! optimise! optimise!
- confirm current implementations match spec
- heap string type

330
build
View file

@ -1,315 +1,63 @@
#!/bin/sh
set -u
SCRIPT_DIR="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
readonly SCRIPT_DIR
readonly HBC_COMMIT="da3dabaf"
readonly HBC_BRANCH="memory-rework"
readonly SRC_DIR="$SCRIPT_DIR/src"
readonly TEST_DIR="$SRC_DIR/test"
readonly BUILD_PATH="$SCRIPT_DIR/target"
readonly CHECKSUM_FILE="$BUILD_PATH/checksum"
readonly LIBLILY_DIR="$SCRIPT_DIR/liblily"
# shellcheck disable=SC2155
readonly LILY_SCRIPT_DIR="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"
readonly LILY_SRC_DIR="${LILY_SRC_DIR:-$LILY_SCRIPT_DIR/src}"
readonly LILY_TEST_DIR="${LILY_TEST_DIR:-$LILY_SCRIPT_DIR/test}"
readonly LILY_BUILD_DIR="${LILY_BUILD_DIR:-$LILY_SCRIPT_DIR/out}"
hbc_flags="--backend-flags=opt_level=none,regalloc_checker=true,enable_verifier=true,use_colocated_libcalls=true,enable_pcc=true,enable_llvm_abi_extensions=true,preserve_frame_pointers=true"
linker="" target="default" run=0 test="none" dump_asm=0 debug=1
readonly HBLANG_GIT="https://git.ablecorp.us/mlokis/hblang"
readonly HBLANG_COMMIT="fcbcaac67dd47887fef81bc62d4b66a6cf071f8c"
readonly HBLANG_BRANCH="main"
readonly HBLANG_CFLAGS="--path-projection lily $LILY_SRC_DIR/lib.hb ${HBLANG_CFLAGS:-}"
die() { error "$1" && exit 1; }
error() { printf "\033[31mERROR\033[0m: %s\n" "$1" >&2; }
die() { error "$2" && exit "$1"; }
error() { printf "\033[31mERROR\033[0m: %s\n" "$1" 1>&2; }
log() { printf "\033[32mINFO\033[0m: %s\n" "$1"; }
warn() { printf "\033[33mWARN\033[0m: %s\n" "$1"; }
# ! for now, ignore this.
check_hbc() {
# command -v hbc >/dev/null 2>&1 && return 0
# log "hblang compiler not found in \$PATH"
# command -v cargo >/dev/null 2>&1 || die "missing both hbc and cargo"
fetch_step() {
cargo_ver=$(cargo install --list | awk '/holey-bytes/ {if(match($0,/[0-9a-f]+/)) print substr($0,RSTART,8)}')
[ "$cargo_ver" = "$HBC_COMMIT" ] && return 0
command -v zig >/dev/null 2>&1 || die 101 "'zig' binary not found in PATH"
command -v git >/dev/null 2>&1 || die 101 "'git' binary not found in PATH"
log "installing hbc($HBC_BRANCH)@$HBC_COMMIT..."
cargo +nightly install --git https://git.ablecorp.us/ableos/holey-bytes hbc --debug --rev "$HBC_COMMIT" --branch "$HBC_BRANCH" >/dev/null 2>&1 ||
die "failed to install hbc (do you have nightly rust installed?)"
}
if [ -d "$LILY_BUILD_DIR/hblang" ]; then
cd "$LILY_BUILD_DIR/hblang" || die 1 "cd to $LILY_BUILD_DIR/hblang failed"
check_changes() {
previous_checksum=""
[ -r "$CHECKSUM_FILE" ] && previous_checksum=$(cat "$CHECKSUM_FILE")
current_checksum=$( (
find "$SRC_DIR" "$LIBLILY_DIR" -type f -exec md5sum {} + | LC_ALL=C sort
printf "%s%s%s" "$linker" "$target" "$hbc_flags"
) | md5sum)
echo "$current_checksum" >"$CHECKSUM_FILE"
[ "$previous_checksum" != "$current_checksum" ]
}
show_help() {
cat <<EOF
Usage: $0 [options]
-r, --run run the output binary
-n, --no-debug disable debug mode
-a, --dump-asm dump assembly to stdout
-l, --linker specify linker (default: auto-detect)
-t, --target target triple/alias (<default>, libc, ableos, hbvm)
-h, --help show this help
-u, --test run tests (lang/lily/<all>)
Examples:
$0 -t ableos
$0 -r -l 'zig cc' -t libc
$0 -a -t ableos > out.hbf
EOF
}
parse_args() {
while [ $# -gt 0 ]; do
case ${1:-""} in
-h | --help)
show_help
exit
;;
-r | --run) run=1 ;;
-n | --no-debug) debug=0 hbc_flags="--backend-flags=opt_level=speed,enable_verifier=false,regalloc_checker=false,enable_alias_analysis=true,use_colocated_libcalls=true,enable_llvm_abi_extensions=true" ;;
-a | --dump-asm) dump_asm=1 ;;
-t | --target)
[ -z "${2:-}" ] && die "'--target' requires a non-empty option argument"
target=$2
shift
;;
# -u | --test)
# test="all"
# ;;
# --test=?*)
# if [ "${1#*=}" = "none" ]; then warn "'--test=none' is redundant"; fi
# test=${1#*=}
# ;;
# --test=)
# die "'--test=' requires a non-empty option argument"
# ;;
--target=?*) target=${1#*=} ;;
--target=)
die "'--target=' requires a non-empty option argument"
;;
-l | --linker)
[ -z "${2:-}" ] && die "'--linker' requires a non-empty option argument"
linker=$2
shift
;;
--linker=?*) linker=${1#*=} ;;
--linker=) die "'--linker' requires a non-empty option argument" ;;
-o | --out)
[ -z "${2:-}" ] && die "'--out' requires a non-empty option argument"
out=$2
shift
;;
--out=?*) out=${1#*=} ;;
--out=) die "'--out' requires a non-empty option argument" ;;
--)
shift
break
;;
-?*) die "unknown option $1" ;;
*) break ;;
esac
shift
done
case $target in
hbvm | ableos)
target="unknown-virt-unknown"
if [ $run = 1 ]; then die "'--run' cannot be set with '--target $target'"; fi
;;
libc | default) target="default" ;;
esac
}
build_failed() {
rm -f "$BUILD_PATH/$target/lily" "$CHECKSUM_FILE"
die "build failed"
}
detect_linker() {
for cmd in "zig cc" clang gcc; do
command -v "${cmd%% *}" >/dev/null 2>&1 && {
linker=$cmd
return
}
done
die "no suitable linker found"
}
post_build() {
[ "$target" = "unknown-virt-unknown" ] && return
[ $run -eq 1 ] && exec "$BUILD_PATH/$target/lily"
[ $dump_asm -eq 1 ] && objdump -d -M intel --no-show-raw-insn "$BUILD_PATH/$target/lily.o" |
awk '/^\s+[0-9a-f]+:/ {sub(/^[ \t]+/, ""); print}'
}
parse_test() {
in_comment=0 exit_code="" args_input="" stdout_expected="" timeout_val=""
while IFS= read -r line; do
case $in_comment in
0) case $line in "/*"*)
in_comment=1
line=${line#/*}
;;
esac ;;
1) case $line in *"*/"*)
line=${line%*/}
in_comment=2
;;
esac ;;
esac
line=$(echo "$line" | sed 's/^[[:space:]]*\*[[:space:]]\{0,1\}//; s/[[:space:]]*$//')
[ $in_comment -ne 0 ] && process_test_line "${line%%*/}"
[ $in_comment -eq 2 ] && break
done <"$1"
}
process_test_line() {
line=$(echo "$1" | sed 's/^[[:space:]]*\*[[:space:]]*//; s/[[:space:]]*$//')
[ -z "$line" ] && return
IFS=: read -r key value <<EOF
$line
EOF
key=$(echo "$key" | tr -d ' ')
value=$(echo "$value" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')
case $key in
exit) exit_code=$value ;;
args) args_input=$value ;;
stdout) stdout_expected=$value ;;
timeout) timeout_val=${value} ;;
esac
}
run_test() {
file=$1 name=$2 output="" rc=0 failed=0
parse_test "$file"
hbc "$file" $hbc_flags >"$BUILD_PATH/test/$name.o" 2>&1
rc=$?
[ $rc -ne 0 ] && {
# todo: quiet mode to hide compilation errors.
error "$name: compilation failed (exit: $(pretty_exitcode "$rc")): $(cat "$BUILD_PATH/test/$name.o")"
return 1
}
[ $debug -eq 0 ] && {
strip --strip-all --strip-debug "$BUILD_PATH/$target/lily.o"
}
$linker "$BUILD_PATH/$target/lily.o" -L"$BUILD_PATH/$target/" -llily -o "$BUILD_PATH/$target/lily" || die "linking failed:"
if [ -n "$timeout_val" ]; then
# shellcheck disable=SC2086
output=$(timeout "$timeout_val" "$BUILD_PATH/test/$name" $args_input 2>&1)
rc=$?
[ $rc -eq 124 ] && {
error "$name: timeout"
failed=1
}
CURR_BRANCH=$(git rev-parse --abbrev-ref HEAD >/dev/null 2>&1)
[ "$CURR_BRANCH" = "$HBLANG_BRANCH" ] || git checkout "$HBLANG_BRANCH" >/dev/null 2>&1
CURR_COMMIT=$(git rev-parse HEAD >/dev/null 2>&1)
[ "$CURR_COMMIT" = "$HBLANG_COMMIT" ] || git checkout "$HBLANG_COMMIT" >/dev/null 2>&1
else
# shellcheck disable=SC2086
output=$("$BUILD_PATH/test/$name" $args_input 2>&1)
rc=$?
mkdir -p "$LILY_BUILD_DIR/hblang"
git clone "$HBLANG_GIT" "$LILY_BUILD_DIR/hblang" --branch "$HBLANG_BRANCH"
cd "$LILY_BUILD_DIR/hblang" || die 1 "cd to $LILY_BUILD_DIR/hblang failed"
git checkout "$HBLANG_COMMIT" >/dev/null 2>&1
fi
[ "$rc" != "$exit_code" ] && {
error "$name: exit code $(pretty_exitcode "$rc") != $exit_code"
failed=1
}
[ -n "$stdout_expected" ] && [ "$output" != "$stdout_expected" ] && {
error "$name: output mismatch
expected: $stdout_expected
got: $output"
failed=1
}
[ $failed -eq 0 ] && log "$test_name completed successfully"
return $failed
}
zig build install
pretty_exitcode() {
exit_code=$1
signal=$((exit_code - 128))
PATH="$LILY_BUILD_DIR/hblang/zig-out/bin:$PATH"
if [ $signal -gt 0 ] && [ $signal -lt 32 ]; then
echo "$exit_code (SIG$(kill -l $signal 2>/dev/null || echo "???"))"
else
echo "$exit_code"
fi
}
cd "$LILY_SCRIPT_DIR" || die 1 "cd to $LILY_SCRIPT_DIR failed"
# todo: this spawns every test all at once. consider limiting to $(nproc) tests at once.
do_tests() {
detect_linker
# temporary because yes :thumbsup:
mkdir -p "$BUILD_PATH/$target" || die "failed to create build dir"
$linker -c "$LIBLILY_DIR/lily.c" -o "$BUILD_PATH/$target/liblily.o"
ar rcs "$BUILD_PATH/$target/liblily.a" "$BUILD_PATH/$target/liblily.o"
mkdir -p "$BUILD_PATH/test" || die "failed to create test dir"
tmpfile=$(mktemp) || die "Failed to create temporary file"
find "${TEST_DIR}/${test#all}" -type f >"$tmpfile" || die "Find command failed"
while IFS= read -r file; do
[ -f "$file" ] || continue
test_name=$(basename "$file" .hb)
log "Testing $test_name"
(run_test "$file" "$test_name") &
done <"$tmpfile"
wait
rm -r "$tmpfile" "$BUILD_PATH/test"
}
do_build() {
mkdir -p "$BUILD_PATH/$target" || die "failed to create $BUILD_PATH/$target"
[ -w "$BUILD_PATH/$target" ] || die "no write permission"
if check_changes || [ ! -e "$BUILD_PATH/$target/lily" ]; then
if [ "$target" = "unknown-virt-unknown" ]; then
out="$BUILD_PATH/$target/lily.axe"
[ $dump_asm -eq 1 ] && {
hbc_flags="$hbc_flags --dump-asm"
out="/dev/stdout"
}
# shellcheck disable=SC2086
hbc "$SRC_DIR/main.hb" $hbc_flags --target="$target" >"$out" || build_failed
else
[ -z "$linker" ] && detect_linker
[ "$target" != "default" ] && hbc_flags="$hbc_flags --target=$target"
# shellcheck disable=SC2086
hbc "$SRC_DIR/main.hb" $hbc_flags >"$BUILD_PATH/$target/lily.o" || build_failed
[ $debug -eq 0 ] && {
strip --strip-all --strip-debug "$BUILD_PATH/$target/lily.o"
}
# temporary because yes :thumbsup:
$linker -c "$LIBLILY_DIR/lily.c" -o "$BUILD_PATH/$target/liblily.o"
ar rcs "$BUILD_PATH/$target/liblily.a" "$BUILD_PATH/$target/liblily.o"
$linker "$BUILD_PATH/$target/lily.o" -L"$BUILD_PATH/$target/" -llily -o "$BUILD_PATH/$target/lily" || die "linking failed"
fi
fi
post_build
}
main() {
parse_args "$@"
mkdir -p "$BUILD_PATH" || die "can't create build dir"
# check_hbc
mkdir -p "$LILY_BUILD_DIR" || die 1 "can't create build dir"
fetch_step
case $test in
none) do_build ;;
lang | lily | all)
[ "$test" = "all" ] && test=""
[ $dump_asm -eq 1 ] && die "'--dump-asm' incompatible with tests (for now)"
[ "$target" != "default" ] && die "'--target' incompatible with tests"
[ $run -eq 1 ] && warn "'--run' is redundant with tests"
do_tests
;;
*) die "unknown test: $test" ;;
esac
return 0
inp="${1:-main.hb}"
[ -z "$inp" ] || [ ! -e "$inp" ] && die 1 "source file '$inp' does not exist"
# shellcheck disable=SC2086
{
hblang $HBLANG_CFLAGS $inp
# todo: dont do this second compile if first fails
hblang $HBLANG_CFLAGS $inp --fmt >/dev/null 2>&1
}
}
main "$@"

11
docs/spec.md
View file

@ -1,11 +0,0 @@
# lily specification
> [!Important] spec version: 0.0.2
> before version 1.0.0, the spec is provisional and may be subject to change.
a collection of guidelines for programmers to use to create lily-compatible implementations.
the following files define the spec:
- [hashers](./spec/hash.md)
- [allocators](./spec/alloc.md)
- [random number generators](./spec/rand.md)
- [iterators](./spec/iter.md)

27
docs/spec/alloc.md
View file

@ -1,27 +0,0 @@
# allocators
> [!tip]
well designed allocators should ensure they only deallocate or reallocate allocations they made.
1. all spec compliant allocators should implement:
> unless otherwise stated, functions can be optionally inline.<br>
> names of arguments are up to programmer discretion.<br>
> names and signature of functions must be identical to shown below.
```rust
Allocator := struct {
new := fn(): Self
/// prepare to be deallocated.
deinit := fn(self: ^Self): void
/// should return null on failure.
/// should dealloc any intermediate allocations on failure.
alloc := fn(self: ^Self, $T: type, count: uint): ?[]T
/// same behaviour as alloc, except:
/// must be zeroed.
alloc_zeroed := fn(self: ^Self, $T: type, count: uint): ?[]T
/// same behaviour as alloc, except:
/// must move data to new allocation,
/// must ensure the old allocation is freed at some point.
realloc := fn(self: ^Self, $T: type, ptr: ^T, new_count: uint): ?[]T
/// must dealloc or schedule the freeing of the given allocation
dealloc := fn(self: ^Self, $T: type, ptr: ^T): void
}
```

24
docs/spec/hash.md
View file

@ -1,24 +0,0 @@
# hashers
1. hashers must not allocate on the heap.
2. all spec compliant hashers should implement:
> unless otherwise stated, functions can be optionally inline.<br>
> names of arguments are up to programmer discretion.<br>
> names and signature of functions must be identical to shown below.
```rust
Hasher := struct {
new := fn(seed: SeedType): Self
/// prepare to be deallocated
deinit := fn(self: ^Self): void
/// should always use a constant or randomised seed
/// randomised seeds should (for now) use lily.Target.getrandom()
/// never use values from the environment
default := fn(): Self
/// pointers: treat as uint
/// slices: read bytes and hash
/// other: hash bytes directly
write := fn(self: ^Self, any: @Any()): void
/// should not reset the state of the hasher
finish := fn(self: ^Self): uint
reset := fn(self: ^Self): void
}
```

20
docs/spec/iter.md
View file

@ -1,20 +0,0 @@
# iterators
## spec to-be-defined
## proposed spec:
```rust
.{IterNext, Iterator} := @use("lily").iter
Iterable := struct {
// ! required
// IterNext == struct { finished: bool, val: T }
next := fn(self: ^Self): IterNext(T)
into_iter := fn(self: Self): Iterator(Self)
// ! proposed
// addition of these two would allow for cheap implementation of `skip`, and `nth` in lily.iter.Iterator
peek := fn(self: ^Self): IterNext(T)
advance := fn(self: ^Self, n: uint): IterNext(T)
// ! proposed (waiting on compiler)
iter := fn(self: ^Self): Iterator(^Self)
}

31
docs/spec/rand.md
View file

@ -1,31 +0,0 @@
# random number generators
1. rngs must not allocate on the heap.
2. the seed of the rng must not change (unless required by the algorithm)
3. all spec compliant rngs should implement:
> unless otherwise stated, functions can be optionally inline.<br>
> names of arguments are up to programmer discretion.<br>
> names and signature of functions must be identical to shown below.
```rust
Random := struct {
new := fn(seed: uint): Self
/// prepare to be deallocated
deinit := fn(self: ^Self): void
/// should always use a constant or randomised seed
/// randomised seeds should always use lily.Target.getrandom()
/// never use values from the environment
default := fn(): Self
/// array|slice: compile error
/// pointer: treat as uint
/// bool: randomise the least significant bit
/// other: randomise
any := fn(self: ^Self, $T: type): T
/// clamp between min and max (inclusive)
range := fn(self: ^Self, min: @Any(), max: @TypeOf(min)): @TypeOf(min)
/// ^array: fill to @lenof(@ChildOf(@TypeOf(buf))) with random bytes
/// slice: fill to buf.len with random bytes
/// other: compile error
fill := fn(self: ^Self, buf: @Any()): void
/// same as fill, except fill each index with a random value rather than filling the whole buffer with random bytes
fill_values := fn(self, ^Self, buf: @Any()): void
}
```

33
docs/spec/tests.md
View file

@ -1,33 +0,0 @@
# tests
tests are written in [src/test](../../src/test/)
1. tests that test the language will be in the [lang](../../src/test/lang) subdirectory
2. tests that test lily will be in the [lily](../../src/test/lily) subdirectory
3. all tests should return any integer or boolean value.
> follow standard practices for exit code.<br>
> `0` for success, `1` for error, etc
4. all tests should contain the test specification (preferably at the top of the file)
- strings & arrays may be multiline
- argument order does not matter
- all test arguments are optional
> tests with no arguments will always pas
- `timeout` is the max length a test can run before failing
- `args` are given to the application executable
- `exit` is the exit status of the program (return code)
5. if test compilation fails, the test will be considered failed
6. tests for lily should try to limit the number of unrelated structures/functions tested.
7. tests for lang should be headless (not rely on lily at all)
a trivial example test:
```rust
expected := .{
exit: 0,
timeout: 0.5,
stdout: "",
args: .[]
}
main := fn(): u8 {
// test will fail after 0.5s
loop {}
}
```

18
hbc-tests/lang/generic_anytype.hb
View file

@ -1,18 +0,0 @@
expected := .{
exit: 0,
}
generic := fn(v: @Any()): uint {
if @TypeOf(v) == uint {
return 1
}
return 0
}
main := fn(): u8 {
a := generic(0)
b := generic(@as(int, 0))
if a != 1 return 1
if b != 0 return 1
return 0
}

17
hbc-tests/lang/indexing.hb
View file

@ -1,17 +0,0 @@
expected := .{
exit: 0,
}
index := fn(buf: @Any()): u8 {
b := buf[0]
buf[0] = 1
return b
}
main := fn(): u8 {
_ = @inline(index, u8.[0, 0, 0])
_ = @inline(index, u8.[0, 0, 0][0..3])
_ = index(u8.[0, 0, 0])
_ = index(u8.[0, 0, 0][0..3])
return 0
}

22
hbc-tests/lang/int_comparison.hb
View file

@ -1,22 +0,0 @@
expected := .{
exit: 0,
}
opaque := fn(v: @Any()): bool {
return v < 0
}
opaque2 := fn(v: @Any()): bool {
return v > 0
}
main := fn(): u8 {
v: int = -10
if !opaque(v) return 1
if !@inline(opaque, v) return 1
if opaque2(v) return 1
if @inline(opaque2, v) return 1
return 0
}

26
hbc-tests/lang/null_check_divergent_branch.hb
View file

@ -1,26 +0,0 @@
expected := .{
exit: 0,
}
A := struct {
inner: u8,
}
opaque := fn(): bool {
return true
}
divergent := fn(): ?A {
if opaque() {
return .(0)
}
return null
}
main := fn(): u8 {
a := divergent()
if a.inner != 0 return 1
b := @inline(divergent)
if b.inner != 0 return 1
return 0
}

21
hbc-tests/lang/ptr_comparison.hb
View file

@ -1,21 +0,0 @@
expected := .{
exit: 0,
}
opaque := fn(): ^u8 {
return @bitcast(0)
}
opaque2 := fn(): ^u8 {
return @bitcast(0)
}
main := fn(): u8 {
if opaque() != opaque2() {
r := opaque() ^ opaque2()
// if you get 2 then the world is ending
if r == 0 return 2
return 1
}
return 0
}

25
hbc-tests/lang/struct_len_loop.hb
View file

@ -1,25 +0,0 @@
expected := .{
exit: 10,
timeout: 1.0,
}
Vec := struct {
len: uint,
new := fn(): Self {
return .(10)
}
pop := fn(self: ^Self): u8 {
self.len -= 1
return 0
}
}
main := fn(): u8 {
vec := Vec.new()
i: u8 = 0
loop if vec.len == 0 break else {
defer i += 1
_ = vec.pop()
}
return i
}

7
hbc-tests/lang/trivial.hb
View file

@ -1,7 +0,0 @@
expected := .{
exit: 0,
}
main := fn(): u8 {
return 0
}

23
hbc-tests/lang/trivial_null_check.hb
View file

@ -1,23 +0,0 @@
expected := .{
exit: 0,
}
opaque := fn(): ?^u8 {
return null
}
$transparent := fn(): ?^u8 {
return null
}
main := fn(): u8 {
result := opaque()
if result != null {
return 1
}
result2 := transparent()
if result2 != null {
return 1
}
return 0
}

37
hbc-tests/lang/unix_timestamp.hb
View file

@ -1,37 +0,0 @@
expected := .{
exit: 0,
}
sum_days := .[0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]
unix_timestamp_secs_lookup_table := fn(year: uint, month: uint, day: uint, hour: uint, minute: uint, second: uint): uint {
is_leap := year % 4 == 0 & (year % 100 != 0 | year % 400 == 0)
days_since_epoch := year * 365 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400 - 719527
total_days := days_since_epoch + day + sum_days[month - 1] + is_leap * (month > 2) - 1;
return total_days * 86400 + hour * 3600 + minute * 60 + second
}
unix_timestamp_secs := fn(year: uint, month: uint, day: uint, hour: uint, minute: uint, second: uint): uint {
is_leap := year % 4 == 0 & (year % 100 != 0 | year % 400 == 0)
days_since_epoch := year * 365 + (year - 1) / 4 - (year - 1) / 100 + (year - 1) / 400 - 719527
// relies on underflowing in (153 * month - 162) / 5 when month = 1
sum_nonleap := (month < 3) * (month - 1) * 31 + (month >= 3) * (153 * month - 162) / 5
total_days := days_since_epoch + day + sum_nonleap + is_leap * (month > 2) - 1
return total_days * 86400 + hour * 3600 + minute * 60 + second
}
main := fn(): bool {
// random date
r := unix_timestamp_secs(2025, 1, 31, 21, 53, 26) != 1738360406
// unix epoch
r |= unix_timestamp_secs(1970, 1, 1, 0, 0, 0) != 0
// y2k38
r |= unix_timestamp_secs(2038, 1, 19, 3, 14, 8) != 1 << 31
// end of year
r |= unix_timestamp_secs(1970, 12, 31, 23, 59, 59) != 31535999
// this doesnt pass: inlining here gives incorrect value.
r |= @inline(unix_timestamp_secs, 2025, 1, 31, 21, 53, 26) != unix_timestamp_secs(2025, 1, 31, 21, 53, 26)
r |= unix_timestamp_secs_lookup_table(2025, 1, 31, 21, 53, 26) != unix_timestamp_secs(2025, 1, 31, 21, 53, 26)
r |= @inline(unix_timestamp_secs_lookup_table, 2025, 1, 31, 21, 53, 26) != unix_timestamp_secs(2025, 1, 31, 21, 53, 26)
return r
}

18
hbc-tests/lily/alloc.ArenaAllocator.hb
View file

@ -1,18 +0,0 @@
expected := .{
exit: 0,
}
lily := @use("../../src/lily/lib.hb")
main := fn(): u8 {
allocator := lily.alloc.ArenaAllocator.new()
defer allocator.deinit()
b := allocator.alloc(u8, 100)
if b == null return 1
c := allocator.alloc(u8, 100)
if c == null return 1
d := allocator.realloc(u8, c.ptr, 100)
if d == null return 1
if d.ptr != c.ptr return 1
return 0
}

18
hbc-tests/lily/alloc.RawAllocator.hb
View file

@ -1,18 +0,0 @@
expected := .{
exit: 0,
}
lily := @use("../../src/lily/lib.hb")
main := fn(): uint {
allocator := lily.alloc.RawAllocator.new()
defer allocator.deinit()
b := allocator.alloc(u8, 100)
if b == null return 1
c := allocator.alloc(u8, 100)
if c == null return 1
d := allocator.realloc(u8, c.ptr, 100)
if d == null return 1
if d.ptr != c.ptr return 1
return 0
}

20
hbc-tests/lily/iter_chars.hb
View file

@ -1,20 +0,0 @@
expected := .{
exit: 0,
stdout: "Hello, World!",
}
lily := @use("../../src/lily/lib.hb")
main := fn(): u8 {
str := lily.string.chars("Hello, ").intersperse(
lily.string.chars("World!"),
).collect([13]u8)
if str != null {
lily.log.info(@as([13]u8, str)[..])
} else {
lily.panic("failed to collect array")
}
return 0
}

8
hbc-tests/lily/log.print.hb
View file

@ -1,8 +0,0 @@
expected := .{exit: 0, timeout: 10, stdout: "Hello, World!"}
lily := @use("../../src/lily/lib.hb")
main := fn(): u8 {
lily.log.print("Hello, World!")
return 0
}

19
liblily/lily.c
View file

@ -1,19 +0,0 @@
#include "lily.h"
#if POSIX
#define _GNU_SOURCE 1
#include <sys/mman.h>
#include <sys/random.h>
#include <stdio.h>
#include <unistd.h>
u32 LILY_POSIX_PROT_READWRITE() {
return PROT_READ | PROT_WRITE;
}
u32 LILY_POSIX_MAP_SHAREDANONYMOUS() {
return MAP_SHARED | MAP_ANONYMOUS;
}
u32 LILY_POSIX_MREMAP_MAYMOVE() {
return MREMAP_MAYMOVE;
}
#endif

28
liblily/lily.h
View file

@ -1,28 +0,0 @@
#ifndef __LILY_H_DEFINED
#define __LILY_H_DEFINED
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) || defined(_POSIX_VERSION)
#define POSIX 1
#else
#define POSIX 0
#endif
typedef unsigned long long int lily_uint;
typedef unsigned int u32;
typedef unsigned short int u16;
typedef unsigned char u8;
typedef u8 bool;
bool is_posix() {
return POSIX;
}
#if POSIX
// we export these constants as functions
// because we cant import c constants in hblang yet
u32 LILY_POSIX_PROT_READWRITE();
u32 LILY_POSIX_MAP_SHAREDANONYMOUS();
u32 LILY_POSIX_MREMAP_MAYMOVE();
#endif // POSIX
#endif // __LILY_H_DEFINED

5
main.hb Normal file
View file

@ -0,0 +1,5 @@
lily := @use("lily")
main := fn(): void {
a := lily.target.func()
}

117
src/alloc/arena.hb
View file

@ -1,117 +0,0 @@
.{Config, Type, Target, log, collections: .{Vec}, alloc: .{RawAllocator}, math} := @use("../lib.hb");
$next_power_of_two := fn(n: uint): uint {
n -= 1
n |= n >> 1
n |= n >> 2
n |= n >> 4
n |= n >> 8
n |= n >> 16
n |= n >> 32
return n + 1
}
$compute_align := fn(size: uint, align: uint): uint {
return size + align - 1 & 1 << @sizeof(uint) * 8 - (align - 1)
}
$fit_pages := fn(size: uint): uint {
return Target.calculate_pages(size) * Target.page_size()
}
$alloc_size := fn(size: uint): uint {
return fit_pages(math.max(next_power_of_two(size), 1))
}
ArenaAllocator := struct {
blocks: Vec([]u8, RawAllocator),
current_block: []u8,
offset: uint,
last_alloc_start: uint,
last_alloc_size: uint,
raw: RawAllocator,
$new := fn(): Self {
// ! THIS BREAKS STUFF!!! RETURNING LOCAL STACK POINTER IDIOT!!!
raw := RawAllocator.new()
blocks := Vec([]u8, RawAllocator).new(&raw)
return .(blocks, Type([]u8).uninit(), 0, 0, 0, raw)
}
deinit := fn(self: ^Self): void {
loop if self.blocks.len() == 0 break else {
block := self.blocks.pop_unchecked()
Target.dealloc(block.ptr, block.len)
}
self.blocks.deinit()
self.raw.deinit();
self.current_block = Type([]u8).uninit()
self.offset = 0
self.last_alloc_start = 0
self.last_alloc_size = 0
log.debug("deinit: arena allocator")
}
alloc := fn(self: ^Self, $T: type, count: uint): ?[]T {
size := @sizeof(T) * count
if Config.debug_assertions() & size == 0 {
log.error("arena: zero sized allocation")
return null
}
aligned := compute_align(self.offset, @alignof(T))
new_space := aligned + size
if new_space > self.current_block.len {
new_size := alloc_size(size)
new_ptr := Target.alloc_zeroed(new_size)
if new_ptr == null return null
new_block := @as(^u8, new_ptr)[0..new_size]
self.blocks.push(new_block)
self.current_block = new_block
self.offset = 0
aligned = 0
}
ptr := self.current_block.ptr + aligned
self.last_alloc_start = aligned
self.last_alloc_size = size
self.offset = aligned + size
log.debug("arena: allocated")
return @as(^T, @bitcast(ptr))[0..count]
}
alloc_zeroed := Self.alloc
realloc := fn(self: ^Self, $T: type, ptr: ^T, new_count: uint): ?[]T {
r0 := @as(^u8, @bitcast(ptr)) != self.current_block.ptr + self.last_alloc_start
r1 := self.last_alloc_start + self.last_alloc_size != self.offset
if r0 | r1 {
if Config.debug_assertions() {
log.error("arena: realloc only supports last allocation")
}
return null
}
size := @sizeof(T) * new_count
if size <= self.last_alloc_size {
if Config.debug_assertions() {
log.warn("arena: useless reallocation (new_size <= old_size)")
}
return ptr[0..new_count]
}
additional := size - self.last_alloc_size
if self.offset + additional <= self.current_block.len {
self.offset += additional
self.last_alloc_size = size
return ptr[0..new_count]
}
new_size := alloc_size(size)
new_ptr := Target.alloc_zeroed(new_size)
if new_ptr == null return null
new_block := @as(^u8, new_ptr)[0..new_size]
Target.memcopy(new_ptr, @bitcast(ptr), self.last_alloc_size)
self.blocks.push(new_block)
self.current_block = new_block
self.offset = size
self.last_alloc_start = 0
self.last_alloc_size = size
log.debug("arena: reallocated")
return @as(^T, @bitcast(new_ptr))[0..new_count]
}
$dealloc := fn(self: ^Self, $T: type, ptr: ^T): void {
if Config.debug_assertions() log.error("arena: dealloc called. (makes no sense)")
}
}

90
src/alloc/arena.hb.old
View file

@ -1,90 +0,0 @@
.{Config, Type, Target, log, collections: .{Vec}, alloc: .{RawAllocator}} := @use("../lib.hb");
$next_power_of_two := fn(n: uint): uint {
n -= 1
n |= n >> 1
n |= n >> 2
n |= n >> 4
n |= n >> 8
n |= n >> 16
n |= n >> 32
return n + 1
}
ArenaAllocator := struct {
offsets: Vec(uint, RawAllocator),
slice: []u8,
cap: uint,
raw: RawAllocator,
$new := fn(): Self {
raw := RawAllocator.new()
offsets := Vec(uint, RawAllocator).new(&raw)
return .(offsets, Type([]u8).uninit(), 0, raw)
}
deinit := fn(self: ^Self): void {
self.offsets.deinit()
self.raw.deinit()
Target.dealloc(self.slice.ptr, self.cap)
self.cap = 0
log.debug("deinit: arena allocator")
}
alloc := fn(self: ^Self, $T: type, count: uint): ?^T {
size := @sizeof(T) * count
if self.slice.len + size > self.cap {
// todo: when size is a power of two, this explodes off unnecessarily.
new_cap := Target.calculate_pages(next_power_of_two(size)) * Target.page_size()
if self.cap == 0 {
self.slice.ptr = @unwrap(Target.alloc_zeroed(new_cap))
} else {
// is fine because self.cap and new_cap are always aligned to Target.page_size()
if self.cap != new_cap {
// ! wait a minute... this makes all of the existing allocations dangling after we do this...
// ! ...damn
self.slice.ptr = @unwrap(Target.realloc(self.slice.ptr, self.cap, new_cap))
}
}
self.cap = new_cap
}
self.offsets.push(self.slice.len)
tmp := self.slice.len
self.slice.len += size
log.debug("allocated arena")
return @bitcast(self.slice.ptr + tmp)
}
alloc_zeroed := Self.alloc
realloc := fn(self: ^Self, $T: type, ptr: ^T, count: uint): ?^T {
offset: uint = @bitcast(ptr - self.slice.ptr)
size := self._find_size(offset)
new_size := @sizeof(T) * count
// no allocations
if size == null return null
if size > new_size {
if Config.debug_assertions() & size != new_size {
log.error("new_size < size (panic for now because it means we dangled a pointer)")
Target.exit(1)
}
return ptr
}
log.debug("reallocated arena")
// todo: remove old offset from offsets
return self.alloc(T, new_size)
}
$dealloc := fn(self: ^Self, $T: type, ptr: $T): void {
log.error("todo: lily.alloc.ArenaAllocator.dealloc")
}
_find_size := fn(self: ^Self, offset: uint): ?uint {
i := 0
// todo: binary search offsets
loop if i == self.offsets.len() break else {
defer i += 1
if offset == self.offsets.get_unchecked(i) {
next_offset := self.offsets.get(i + 1)
if next_offset == null return self.cap - offset
return next_offset - offset
}
}
return null
}
}

2
src/alloc/lib.hb
View file

@ -1,2 +0,0 @@
.{RawAllocator} := @use("raw.hb");
.{ArenaAllocator} := @use("arena.hb")

62
src/alloc/raw.hb
View file

@ -1,62 +0,0 @@
.{Config, Target, Type, log, collections: .{Vec}} := @use("../lib.hb");
RawAllocator := struct {
slice: []u8,
$new := fn(): Self return .(Type([]u8).uninit())
$deinit := fn(self: ^Self): void {
self.dealloc(void, Type(^void).uninit())
}
$alloc_zeroed := fn(self: ^Self, $T: type, count: uint): ?[]T {
return Self._alloc_common(self, T, count, true)
}
$alloc := fn(self: ^Self, $T: type, count: uint): ?[]T {
return Self._alloc_common(self, T, count, false)
}
realloc := fn(self: ^Self, $T: type, ptr: ^T, count: uint): ?[]T {
size := count * @sizeof(T);
if size == 0 return Type([]T).uninit();
if self.slice.len == 0 return null;
if Target.calculate_pages(self.slice.len) >= Target.calculate_pages(size) {
return @as(^T, @bitcast(self.slice.ptr))[0..count]
}
new_ptr := Target.realloc(self.slice.ptr, self.slice.len, size);
if new_ptr == null return null
self.slice = @as(^u8, new_ptr)[0..size];
log.debug("reallocated: raw");
return @as(^T, @bitcast(new_ptr))[0..count]
}
// ! INLINING THIS FUNCTION CAUSES MISCOMPILATION!! DO NOT INLINE IT!! :) :) :)
dealloc := fn(self: ^Self, $T: type, ptr: ^T): void {
if self.slice.len > 0 {
Target.dealloc(self.slice.ptr, self.slice.len)
log.debug("deallocated: raw")
};
*self = Self.new()
}
_alloc_common := fn(self: ^Self, $T: type, count: uint, zeroed: bool): ?[]T {
size := count * @sizeof(T);
if size == 0 return Type([]T).uninit();
if Target.calculate_pages(self.slice.len) >= Target.calculate_pages(size) {
return @as(^T, @bitcast(self.slice.ptr))[0..count]
}
ptr := Type(?^u8).uninit()
if zeroed {
ptr = Target.alloc_zeroed(size)
} else {
ptr = Target.alloc(size)
}
if ptr == null return null
if self.slice.len > 0 {
Target.dealloc(self.slice.ptr, self.slice.len)
}
self.slice = @as(^u8, ptr)[0..size]
log.debug("allocated: raw")
return @as(^T, @bitcast(ptr))[0..count]
}
}

BIN
src/assets/zeroed
View file

Binary file not shown.

246
src/collections/hashmap.hb
View file

@ -1,246 +0,0 @@
.{collections: .{Vec}, iter: .{Iterator, IterNext}, Type, TypeOf, log} := @use("../lib.hb")
Item := fn($Key: type, $Value: type): type return packed struct {
key: Key,
value: Value,
}
Bucket := fn($Key: type, $Value: type, $Allocator: type): type {
return Vec(Item(Key, Value), Allocator)
}
Buckets := fn($Key: type, $Value: type, $Allocator: type): type {
return Vec(Bucket(Key, Value, Allocator), Allocator)
}
$equals := fn(lhs: @Any(), rhs: @TypeOf(lhs)): bool {
match TypeOf(lhs).kind() {
.Slice => return lhs.ptr == rhs.ptr & lhs.len == rhs.len,
_ => return lhs == rhs,
}
}
// temporarily here.
$next_power_of_two := fn(n: uint): uint {
n -= 1
n |= n >> 1
n |= n >> 2
n |= n >> 4
n |= n >> 8
n |= n >> 16
n |= n >> 32
return n + 1
}
HashMap := fn($Key: type, $Value: type, $Hasher: type, $Allocator: type): type return struct {
allocator: ^Allocator,
hasher: Hasher,
buckets: Buckets(Key, Value, Allocator),
length: uint,
new := fn(allocator: ^Allocator): Self {
hasher := Hasher.default()
buckets := Buckets(Key, Value, Allocator).with_capacity(allocator, 16)
// ! (possibly solved)
// ! (compiler) bug: have to use for-loop here rather than using buckets.len(), otherwise we loop infinitely
i := 0
loop if i == 16 break else {
defer i += 1
buckets.push(Bucket(Key, Value, Allocator).new(allocator))
}
// also need to add this here...?
buckets.slice.len = 16
return .(allocator, hasher, buckets, 0)
}
// seems like bad performance...
resize := fn(self: ^Self): void {
new_cap := next_power_of_two(self.buckets.len() * 2)
new_buckets := @TypeOf(self.buckets).with_capacity(self.allocator, new_cap)
// same compiler bug as above...
i := 0
loop if i == new_cap break else {
defer i += 1
new_buckets.push(Bucket(Key, Value, Allocator).new(self.allocator))
}
new_buckets.slice.len = new_cap
loop if self.buckets.len() == 0 break else {
bucket := self.buckets.pop_unchecked()
loop if bucket.len() == 0 break else {
item := bucket.pop_unchecked()
self.hasher.write(item.key)
idx := self.hasher.finish() & new_cap - 1
self.hasher.reset()
new_bucket := new_buckets.get_ref_unchecked(idx)
new_bucket.push(item)
}
bucket.deinit()
}
self.buckets.deinit()
self.buckets = new_buckets
}
deinit := fn(self: ^Self): void {
loop {
bucket := self.buckets.pop()
if bucket == null break;
bucket.deinit()
}
self.buckets.deinit()
self.hasher.deinit()
self.length = 0
}
insert := fn(self: ^Self, key: Key, value: Value): ^Value {
self.hasher.write(key)
idx := self.hasher.finish() & self.buckets.len() - 1
self.hasher.reset()
if self.length * 4 > self.buckets.len() * 3 {
@inline(self.resize)
}
bucket_opt := self.buckets.get_ref(idx)
if bucket_opt == null {
self.buckets.push(Bucket(Key, Value, Allocator).new(self.allocator))
bucket_opt = self.buckets.get_ref(self.buckets.len() - 1)
}
bucket := @unwrap(bucket_opt)
i := 0
loop if i == bucket.len() break else {
defer i += 1
pair := bucket.get_ref_unchecked(i)
if equals(pair.key, key) {
pair.value = value
// ! weird no-op cast to stop type system from complaining.
// don't quite know what is going on here...
return &@as(^Item(Key, Value), pair).value
}
}
bucket.push(.{key, value})
pair := bucket.get_ref_unchecked(bucket.len() - 1)
self.length += 1
return &@as(^Item(Key, Value), pair).value
}
get := fn(self: ^Self, key: Key): ?Value {
self.hasher.write(key)
idx := self.hasher.finish() & self.buckets.len() - 1
self.hasher.reset()
bucket := self.buckets.get_ref(idx)
if bucket == null return null
i := 0
loop if i == bucket.len() break else {
defer i += 1
pair := bucket.get_ref_unchecked(i)
if equals(pair.key, key) {
return pair.value
}
}
return null
}
// references may be invalidated if value is removed from hashmap after get_ref is used.
get_ref := fn(self: ^Self, key: Key): ?^Value {
self.hasher.write(key)
idx := self.hasher.finish() & self.buckets.len() - 1
self.hasher.reset()
bucket := self.buckets.get_ref(idx)
if bucket == null return null
i := 0
loop if i == bucket.len() break else {
defer i += 1
pair := bucket.get_ref_unchecked(i)
if equals(pair.key, key) {
return &@as(^Item(Key, Value), pair).value
}
}
return null
}
remove := fn(self: ^Self, key: Key): ?Value {
self.hasher.write(key)
idx := self.hasher.finish() & self.buckets.len() - 1
self.hasher.reset()
bucket := self.buckets.get_ref(idx)
if bucket == null return null
i := 0
loop if i == bucket.len() break else {
defer i += 1
pair := bucket.get_ref_unchecked(i)
if equals(pair.key, key) {
self.length -= 1
return @unwrap(bucket.swap_remove(i)).value
}
}
return null
}
// todo: write keys, values
$items := fn(self: Self): Iterator(Items(Self, Item(Key, Value))) {
return .(.(self, 0, 0))
}
$keys := fn(self: Self): Iterator(Keys(Self, Key)) {
return .(.(self, 0, 0))
}
$values := fn(self: Self): Iterator(Values(Self, Value)) {
return .(.(self, 0, 0))
}
$len := fn(self: ^Self): uint return self.length
}
// todo: make these efficient and reduce code duplication
Items := fn($H: type, $I: type): type return struct {
// has to be owned here... (possibly due to bug) great...
map: H,
bucket: uint,
sub: uint,
next := fn(self: ^Self): IterNext(I) {
bucket := self.map.buckets.get_ref(self.bucket)
if bucket == null return .(true, Type(I).uninit())
sub := bucket.get(self.sub)
if sub == null {
self.sub = 0
self.bucket += 1
return self.next()
}
self.sub += 1
return .(false, sub)
}
}
Values := fn($H: type, $V: type): type return struct {
// has to be owned here... (possibly due to bug) great...
map: H,
bucket: uint,
sub: uint,
next := fn(self: ^Self): IterNext(V) {
bucket := self.map.buckets.get_ref(self.bucket)
if bucket == null return .(true, Type(V).uninit())
sub := bucket.get(self.sub)
if sub == null {
self.sub = 0
self.bucket += 1
return self.next()
}
self.sub += 1
return .(false, sub.value)
}
}
Keys := fn($H: type, $K: type): type return struct {
// has to be owned here... (possibly due to bug) great...
map: H,
bucket: uint,
sub: uint,
next := fn(self: ^Self): IterNext(K) {
bucket := self.map.buckets.get_ref(self.bucket)
if bucket == null return .(true, Type(K).uninit())
sub := bucket.get(self.sub)
if sub == null {
self.sub = 0
self.bucket += 1
return self.next()
}
self.sub += 1
return .(false, sub.key)
}
}

2
src/collections/lib.hb
View file

@ -1,2 +0,0 @@
.{Vec} := @use("vec.hb");
.{HashMap} := @use("hashmap.hb")

107
src/collections/vec.hb
View file

@ -1,107 +0,0 @@
.{memmove, Type, log, panic, alloc, quicksort, compare, iter} := @use("../lib.hb");
Vec := fn($T: type, $Allocator: type): type return struct {
slice: []T,
allocator: ^Allocator,
cap: uint = 0,
$new := fn(allocator: ^Allocator): Self return .{slice: Type([]T).uninit(), allocator}
$with_capacity := fn(allocator: ^Allocator, cap: uint): Self {
new_alloc := allocator.alloc(T, cap)
if new_alloc == null {
// todo: handle this
return
}
return .{slice: new_alloc[0..0], allocator, cap}
}
deinit := fn(self: ^Self): void {
// currently does not handle deinit of T if T allocates memory
if self.cap > 0 self.allocator.dealloc(T, self.slice.ptr)
self.slice = Type([]T).uninit()
self.cap = 0
if Allocator == alloc.RawAllocator {
log.debug("deinit: vec (w/ raw allocator)")
} else {
log.debug("deinit: vec")
}
}
// todo: maybe make this exponential instead
reserve := fn(self: ^Self, n: uint): void {
if self.len() + n <= self.cap return;
new_alloc := self.allocator.realloc(T, self.slice.ptr, self.cap + n)
if new_alloc == null {
// todo: handle this
return
}
self.cap += n
self.slice.ptr = new_alloc
}
push := fn(self: ^Self, value: T): void {
if self.slice.len == self.cap {
if self.cap == 0 {
new_alloc := self.allocator.alloc(T, 1)
if new_alloc == null {
// todo: handle this
return
}
self.slice.ptr = new_alloc.ptr
self.cap = new_alloc.len
} else {
new_alloc := self.allocator.realloc(T, self.slice.ptr, self.cap * 2)
if new_alloc == null {
// todo: handle this
return
}
self.slice.ptr = new_alloc.ptr
self.cap = new_alloc.len
}
}
self.slice[self.slice.len] = value
self.slice.len += 1
}
get := fn(self: ^Self, n: uint): ?T {
if n >= self.slice.len return null
return self.slice[n]
}
$get_unchecked := fn(self: ^Self, n: uint): T return self.slice[n]
get_ref := fn(self: ^Self, n: uint): ?^T {
if n >= self.slice.len return null
return self.slice.ptr + n
}
$get_ref_unchecked := fn(self: ^Self, n: uint): ^T return self.slice.ptr + n
pop := fn(self: ^Self): ?T {
if self.slice.len == 0 return null
self.slice.len -= 1
// as far as im aware this is not undefined behaviour.
return self.slice[self.slice.len]
}
$pop_unchecked := fn(self: ^Self): T {
self.slice.len -= 1
// as far as im aware this is not undefined behaviour. (2)
return self.slice[self.slice.len]
}
remove := fn(self: ^Self, n: uint): ?T {
if n >= self.slice.len return null
if n + 1 == self.slice.len return self.pop_unchecked()
temp := self.slice[n]
memmove(self.slice.ptr + n, self.slice.ptr + n + 1, (self.slice.len - n - 1) * @sizeof(T))
self.slice.len -= 1
return temp
}
swap_remove := fn(self: ^Self, n: uint): ?T {
if n >= self.slice.len return null
if n + 1 == self.slice.len return self.pop_unchecked()
temp := self.slice[n]
self.slice[n] = self.pop_unchecked()
return temp
}
find := fn(self: ^Self, rhs: T): ?uint {
i := 0
loop if self.get_unchecked(i) == rhs return i else if i == self.slice.len return null else i += 1
}
$sort_with := fn(self: ^Self, $func: type): void {
_ = quicksort(func, self.slice, 0, self.slice.len - 1)
}
$sort := fn(self: ^Self): void self.sort_with(compare)
$len := fn(self: ^Self): uint return self.slice.len
$capacity := fn(self: ^Self): uint return self.cap
}

272
src/fmt.hb
View file

@ -1,272 +0,0 @@
.{target, Type, TypeOf, string, memcopy, panic} := @use("lib.hb")
$FP_TOLERANCE := 0.00000001
fmt_int := fn(buf: []u8, v: @Any(), radix: @TypeOf(v)): uint {
prefix_len := 0
if TypeOf(v).is_signed_int() & v < 0 {
v = -v
buf[0] = '-'
prefix_len += 1
}
if radix == 16 {
memcopy(buf.ptr + prefix_len, "0x".ptr, 2)
prefix_len += 2
} else if radix == 2 {
memcopy(buf.ptr + prefix_len, "0b".ptr, 2)
prefix_len += 2
} else if radix == 8 {
memcopy(buf.ptr + prefix_len, "0o".ptr, 2)
prefix_len += 2
}
if v == 0 {
buf[prefix_len] = '0'
return prefix_len + 1
}
i := prefix_len
loop if v <= 0 break else {
remainder := v % radix
v /= radix
// ! (libc) workaround for compiler bug
// if remainder > 9 {
// buf[i] = @intcast(remainder - 10 + 'A')
// } else {
// buf[i] = @intcast(remainder + '0')
// }
if remainder > 9 {
remainder += 'A' - 10
} else {
remainder += '0'
}
buf[i] = @intcast(remainder)
i += 1
}
string.reverse(buf[prefix_len..i])
return i
}
// ! (libc) (compiler) keeps complaining about 'not yet implemented' only on libc
fmt_float := fn(buf: []u8, v: @Any(), precision: uint, radix: int): uint {
prefix_len := 0
if v < 0 {
v = -v
buf[0] = '-'
prefix_len += 1
}
if radix == 16 {
memcopy(buf.ptr + prefix_len, "0x".ptr, 2)
prefix_len += 2
} else if radix == 2 {
memcopy(buf.ptr + prefix_len, "0b".ptr, 2)
prefix_len += 2
} else if radix == 8 {
memcopy(buf.ptr + prefix_len, "0o".ptr, 2)
prefix_len += 2
}
integer_part := @fti(v)
fractional_part := v - @itf(integer_part)
i := prefix_len
loop if integer_part == 0 & i > prefix_len break else {
remainder := integer_part % radix
integer_part /= radix
if remainder > 9 {
buf[i] = @intcast(remainder - 10 + 'A')
} else {
buf[i] = @intcast(remainder + '0')
}
i += 1
}
string.reverse(buf[prefix_len..i])
if fractional_part > FP_TOLERANCE {
buf[i] = '.'
i += 1
p := precision
loop if p <= 0 | fractional_part < FP_TOLERANCE break else {
fractional_part *= @itf(radix)
digit := @fti(fractional_part)
if digit > 9 {
buf[i] = @intcast(digit - 10 + 'A')
} else {
buf[i] = @intcast(digit + '0')
}
i += 1
fractional_part -= @itf(digit)
p -= 1
}
}
return i
}
fmt_bool := fn(buf: []u8, v: bool): uint {
if v {
memcopy(buf.ptr, "true".ptr, 4)
return 4
} else {
memcopy(buf.ptr, "false".ptr, 5)
return 5
}
}
fmt_container := fn(buf: []u8, v: @Any()): uint {
T := TypeOf(v)
i := 0
len := 0
if T.kind() == .Struct {
memcopy(buf.ptr + len, T.name().ptr, T.name().len)
len += T.name().len
memcopy(buf.ptr + len, ".(".ptr, 2)
len += 2
} else if T.kind() == .Slice | T.kind() == .Array {
memcopy(buf.ptr + len, T.Child().name().ptr, T.Child().name().len)
len += T.Child().name().len
memcopy(buf.ptr + len, ".[".ptr, 2)
len += 2
} else if T.kind() == .Tuple {
memcopy(buf.ptr + len, ".(".ptr, 2)
len += 2
}
if T.kind() == .Slice {
loop if i == v.len break else {
len += format(buf[len..], v[i])
i += 1
if i < v.len {
memcopy(buf.ptr + len, ", ".ptr, 2)
len += 2
}
}
} else {
$loop if i == T.len() break else {
len += format(buf[len..], v[i])
i += 1
if i < T.len() {
memcopy(buf.ptr + len, ", ".ptr, 2)
len += 2
}
}
}
if T.kind() == .Struct | T.kind() == .Tuple {
*(buf.ptr + len) = ')'
len += 1
} else if T.kind() == .Slice | T.kind() == .Array {
*(buf.ptr + len) = ']'
len += 1
}
return len
}
fmt_optional := fn(buf: []u8, v: @Any()): uint {
if v != null return format(buf, @as(@ChildOf(@TypeOf(v)), v))
memcopy(buf.ptr, @nameof(@TypeOf(v)).ptr, @nameof(@TypeOf(v)).len)
memcopy(buf.ptr + @nameof(@TypeOf(v)).len, ".null".ptr, 5)
return @nameof(@TypeOf(v)).len + 5
}
// todo: clean up this and other functions
fmt_enum := fn(buf: []u8, v: @Any()): uint {
T := @TypeOf(v)
len := @nameof(T).len;
memcopy(buf.ptr, @nameof(T).ptr, len)
memcopy(buf.ptr + len, ".(".ptr, 2)
len += 2
len += fmt_int(buf[len..], @as(Type(T).USize(), @bitcast(v)), 10);
memcopy(buf.ptr + len, ")".ptr, 1)
return len + 1
}
format := fn(buf: []u8, v: @Any()): uint {
T := TypeOf(v)
match T.kind() {
.Pointer => return fmt_int(buf, @as(uint, @bitcast(v)), 16),
.Builtin => {
if T.is_int() return fmt_int(buf, v, 10)
if T.is_bool() return fmt_bool(buf, v)
if T.is_float() return fmt_float(buf, v, 1 << 32, 10)
},
.Struct => return fmt_container(buf, v),
.Tuple => return fmt_container(buf, v),
.Slice => {
if T.This() == []u8 {
*buf.ptr = '"'
memcopy(buf.ptr + 1, v.ptr, v.len);
*(buf.ptr + 1 + v.len) = '"'
return v.len + 2
}
return fmt_container(buf, v)
},
.Array => return fmt_container(buf, v),
.Optional => return fmt_optional(buf, v),
.Enum => return fmt_enum(buf, v),
_ => @error("format(", T, ") is not supported."),
}
return 0
}
// ! (compiler) bug: panic doesnt work here specifically. causes parser issue.
format_with_str := fn(str: []u8, buf: []u8, v: @Any()): uint {
T := TypeOf(v)
n := string.count(str, '{')
// if n != string.count(str, '}') panic("Missing closing '}' in format string.")
if n != string.count(str, '}') die
if T.kind() == .Tuple {
// if T.len() != n panic("Format string has different number of '{}' than args given.")
if T.len() != n die
m := 0
i := 0
j := 0
$loop if m > T.len() break else {
if m == T.len() {
loop if i == str.len break else {
buf[j] = str[i]
i += 1
j += 1
}
m += 1
} else {
v2 := v[m]
loop if i == str.len break else {
if str[i] == '{' & str[i + 1] == '}' {
j += format(buf[j..], v2)
i += 2
break
} else {
buf[j] = str[i]
i += 1
j += 1
}
}
m += 1
}
}
return j
} else if n > 1 {
// panic("Format string has multiple '{}' but value provided is not a tuple.")
die
} else {
i := 0
j := 0
loop if i == str.len break else {
if str[i] == '{' & str[i + 1] == '}' {
j += format(buf[j..], v)
i += 2
} else {
buf[j] = str[i]
i += 1
j += 1
}
}
return j
}
}

209
src/hash/foldhash.hb
View file

@ -1,209 +0,0 @@
/*
* This code is an implementation of the FoldHash algorithm from https://github.com/orlp/foldhash,
* originally written by Orson Peters under the zlib license.
*
* Changes to the original code were made to meet the simplicity requirements of this implementation.
* Behaviour aims to be equivalent but not identical to the original code.
*
* Copyright (c) 2024 Orson Peters
*
* This software is provided 'as-is', without any express or implied warranty. In
* no event will the authors be held liable for any damages arising from the use of
* this software.
*
* Permission is granted to anyone to use this software for any purpose, including
* commercial applications, and to alter it and redistribute it freely, subject to
* the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not claim
* that you wrote the original software. If you use this software in a product,
* an acknowledgment in the product documentation would be appreciated but is
* not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/;
.{math, Target, TypeOf} := @use("../lib.hb")
$ARBITRARY0 := 0x243F6A8885A308D3
$ARBITRARY1 := 0x13198A2E03707344
$ARBITRARY2 := 0xA4093822299F31D0
$ARBITRARY3 := 0x82EFA98EC4E6C89
$ARBITRARY4 := 0x452821E638D01377
$ARBITRARY5 := 0xBE5466CF34E90C6C
$ARBITRARY6 := 0xC0AC29B7C97C50DD
$ARBITRARY7 := 0x3F84D5B5B5470917
$ARBITRARY8 := 0x9216D5D98979FB1B
$ARBITRARY9 := 0xD1310BA698DFB5AC
$FIXED_GLOBAL_SEED := uint.[ARBITRARY4, ARBITRARY5, ARBITRARY6, ARBITRARY7]
U128 := packed struct {a: uint, b: uint}
$folded_multiply := fn(x: uint, y: uint): uint {
lx: u32 = @intcast(x)
ly: u32 = @as(u32, @intcast(y))
hx := x >> 32
hy := y >> 32
afull := lx * hy
bfull := hx * ly
return afull ^ (bfull << 32 | bfull >> 32)
}
// ! (libc) (compiler) panics with "not yet implemented: bool" when using slice
hash_bytes_medium := fn(bytes: ^u8, len: uint, s0: uint, s1: uint, fold_seed: uint): uint {
lo := bytes
end := bytes + len
hi := end - 16
loop if lo >= hi return s0 ^ s1 else {
a := *@as(^uint, @bitcast(lo))
b := *@as(^uint, @bitcast(lo + 8))
c := *@as(^uint, @bitcast(hi))
d := *@as(^uint, @bitcast(hi + 8))
s0 = folded_multiply(a ^ s0, c ^ fold_seed)
s1 = folded_multiply(b ^ s1, d ^ fold_seed)
hi -= 16
lo += 16
}
return s0 ^ s1
}
hash_bytes_long := fn(bytes: ^u8, len: uint, s0: uint, s1: uint, s2: uint, s3: uint, fold_seed: uint): uint {
$chunk_size := 64
chunks := len / chunk_size
remainder := len % chunk_size
ptr := bytes
i := 0
loop if i >= chunks break else {
a := *@as(^uint, @bitcast(ptr))
b := *@as(^uint, @bitcast(ptr + 8))
c := *@as(^uint, @bitcast(ptr + 16))
d := *@as(^uint, @bitcast(ptr + 24))
e := *@as(^uint, @bitcast(ptr + 32))
f := *@as(^uint, @bitcast(ptr + 40))
g := *@as(^uint, @bitcast(ptr + 48))
h := *@as(^uint, @bitcast(ptr + 56))
s0 = folded_multiply(a ^ s0, e ^ fold_seed)
s1 = folded_multiply(b ^ s1, f ^ fold_seed)
s2 = folded_multiply(c ^ s2, g ^ fold_seed)
s3 = folded_multiply(d ^ s3, h ^ fold_seed)
ptr += chunk_size
i += 1
}
s0 ^= s2
s1 ^= s3
if remainder > 0 {
remainder_start := bytes + len - math.max(remainder, 16)
return hash_bytes_medium(remainder_start, math.max(remainder, 16), s0, s1, fold_seed)
}
return s0 ^ s1
}
FoldHasher := struct {
accumulator: uint,
original_seed: uint,
sponge: U128,
sponge_len: u8,
fold_seed: uint,
expand_seed: uint,
expand_seed2: uint,
expand_seed3: uint,
$new := fn(seed: uint): Self {
return .(
seed,
seed,
.(0, 0),
0,
FIXED_GLOBAL_SEED[0],
FIXED_GLOBAL_SEED[1],
FIXED_GLOBAL_SEED[2],
FIXED_GLOBAL_SEED[3],
)
}
$deinit := fn(self: ^Self): void {
}
$default := fn(): Self {
a := 0
Target.getrandom(@bitcast(&a), @sizeof(@TypeOf(a)))
return Self.new(a)
}
write := fn(self: ^Self, any: @Any()): void {
T := TypeOf(any)
// ! broken
// if T.is_int() {
// bits := 8 * T.size()
// if @as(uint, self.sponge_len) + bits > 128 {
// self.accumulator = folded_multiply(self.sponge.b ^ self.accumulator, self.sponge.a ^ self.fold_seed)
// self.sponge = *@bitcast(&any)
// self.sponge_len = @intcast(bits)
// } else {
// // note: this behaviour is incorrect with U128 struct
// self.sponge |= *@as(^U128, @bitcast(&any)) << *@as(^U128, @bitcast(&self.sponge_len))
// self.sponge_len += @intcast(bits)
// }
// return
// }
bytes := @as(^u8, @bitcast(&any))
len := 0
// ! (libc) (compiler) crashes when setting len = any.len
match T.kind() {
.Slice => {
len = any.len
bytes = any.ptr
},
_ => len = @sizeof(T.This()),
}
s0 := self.accumulator
s1 := self.expand_seed
if len <= 16 {
if len >= 8 {
s0 ^= *@bitcast(bytes)
s1 ^= *@bitcast(bytes + len - 8)
} else if len >= 4 {
s0 ^= *@as(^u32, @bitcast(bytes))
s1 ^= *@as(^u32, @bitcast(bytes + len - 4))
} else if len > 0 {
lo := *bytes
mid := *(bytes + len / 2)
hi := *(bytes + len - 1)
s0 ^= lo
s1 ^= @as(uint, hi) << 8 | mid
}
self.accumulator = folded_multiply(s0, s1)
} else if len < 256 {
self.accumulator = hash_bytes_medium(bytes, len, s0, s1, self.fold_seed)
} else {
self.accumulator = @inline(hash_bytes_long, bytes, len, s0, s1, self.expand_seed2, self.expand_seed3, self.fold_seed)
}
}
finish := fn(self: ^Self): uint {
if self.sponge_len > 0 {
return folded_multiply(self.sponge.b ^ self.accumulator, self.sponge.a ^ self.fold_seed)
} else {
return self.accumulator
}
}
reset := fn(self: ^Self): void {
self.accumulator = self.original_seed
self.sponge = .(0, 0)
self.sponge_len = 0
}
}

1
src/hash/lib.hb
View file

@ -1 +0,0 @@
.{FoldHasher} := @use("foldhash.hb")

217
src/iter.hb
View file

@ -1,217 +0,0 @@
.{Type} := @use("lib.hb")
IterNext := fn($T: type): type return struct {finished: bool, val: T}
// ! todo: complain about inlining rules
// ! how am i supposed to get optimal performance out of this if inlining is sometimes not allowed
// ! todo:
// * Iterator.peek
/// Iterator struct. Implements iterator stuff for you if you implement `into_iter` for your struct.
Iterator := fn($T: type): type {
$Next := @TypeOf(T.next(idk))
$Value := @TypeOf(T.next(idk).val)
return struct {
inner: T,
$next := fn(self: ^Self): Next {
return self.inner.next()
}
$map := fn(self: Self, $_map: type): Iterator(Map(T, _map)) {
return .(.(self))
}
$enumerate := fn(self: Self): Iterator(Enumerate(T)) {
return .(.{iter: self})
}
$take := fn(self: Self, n: uint): Iterator(Take(T)) {
return .(.{iter: self, end: n})
}
$skip := fn(self: Self, n: uint): Iterator(Skip(T)) {
return .(.{iter: self, step: n})
}
$chain := fn(self: Self, rhs: @Any()): Iterator(Chain(T, @TypeOf(rhs))) {
return .(.{iter0: self, iter1: .(rhs)})
}
$intersperse := fn(self: Self, rhs: @Any()): Iterator(Intersperse(T, @TypeOf(rhs))) {
return .(.{iter0: self, iter1: .(rhs)})
}
for_each := fn(self: ^Self, $_for_each: type): void {
loop {
x := self.next()
if x.finished break
_ = _for_each(x.val)
}
}
fold := fn(self: ^Self, $_fold: type, sum: @Any()): @TypeOf(sum) {
loop {
x := self.next()
if x.finished return sum
sum = _fold(sum, x.val)
}
}
nth := fn(self: ^Self, n: uint): ?Value {
i := 0
loop {
x := self.next()
if x.finished return null else if i == n return x.val
i += 1
}
}
collect := fn(self: ^Self, $A: type): ?A {
if Type(A).kind() != .Array {
@error("unsupported collect (for now)")
}
if @ChildOf(A) != Value {
@error("cannot collect of iterator of type", Value, "into type", A)
}
cont := Type(A).uninit()
i := 0
loop {
defer i += 1
x := self.next()
if i == @lenof(A) & x.finished return cont
if i == @lenof(A) | x.finished return null
cont[i] = x.val
}
}
}
}
/// Map is lazy. Simply calling `my_iter.map(func)` will not cause any execution.
Map := fn($T: type, $_map: type): type {
$Next := @TypeOf(_map(@as(@TypeOf(T.next(idk).val), idk)))
return struct {
iter: Iterator(T),
next := fn(self: ^Self): IterNext(Next) {
x := self.iter.inner.next()
return .(x.finished, _map(x.val))
}
}
}
IterEnumerate := fn($T: type): type return struct {n: uint, val: T}
Enumerate := fn($T: type): type {
$Next := IterEnumerate(@TypeOf(T.next(idk).val))
return struct {
iter: Iterator(T),
n: uint = 0,
next := fn(self: ^Self): IterNext(Next) {
self.n += 1
x := self.iter.inner.next()
return .(x.finished, .(self.n, x.val))
}
}
}
Take := fn($T: type): type {
$Next := @TypeOf(T.next(idk).val)
return struct {
iter: Iterator(T),
n: uint = 0,
end: uint,
next := fn(self: ^Self): IterNext(Next) {
self.n += 1
x := Type(IterNext(Next)).uninit()
if self.n > self.end return .(true, x.val)
return self.iter.inner.next()
}
}
}
Skip := fn($T: type): type {
$Next := @TypeOf(T.next(idk).val)
return struct {
iter: Iterator(T),
step: uint,
next := fn(self: ^Self): IterNext(Next) {
n := 0
loop {
x := self.iter.next()
if n == self.step | x.finished return x
n += 1
}
}
}
}
ChainState := enum {
Iter0,
Iter0Finished,
BothFinished,
}
Chain := fn($A: type, $B: type): type {
$Next := @TypeOf(A.next(idk).val)
$Next1 := @TypeOf(B.next(idk).val)
if Next1 != Next @error("Both iterators should return the same type")
return struct {
iter0: Iterator(A),
iter1: Iterator(B),
state: ChainState = .Iter0,
next := fn(self: ^Self): IterNext(Next) {
x := Type(IterNext(Next)).uninit()
match self.state {
.Iter0 => {
x = self.iter0.inner.next()
if x.finished {
self.state = .Iter0Finished
return self.next()
}
},
.Iter0Finished => {
x = self.iter1.inner.next()
if x.finished self.state = .BothFinished
},
_ => {
},
}
return .(self.state == .BothFinished, x.val)
}
}
}
IntersperseState := enum {
Iter0,
Iter1,
Iter0Finished,
Iter1Finished,
}
Intersperse := fn($A: type, $B: type): type {
$Next := @TypeOf(A.next(idk).val)
$Next1 := @TypeOf(B.next(idk).val)
if Next1 != Next @error("Both iterators should return the same type")
return struct {
iter0: Iterator(A),
iter1: Iterator(B),
state: IntersperseState = .Iter0,
next := fn(self: ^Self): IterNext(Next) {
x := Type(IterNext(Next)).uninit()
match self.state {
.Iter0 => {
x = self.iter0.inner.next()
if x.finished self.state = .Iter0Finished else self.state = .Iter1
},
.Iter1 => {
x = self.iter1.inner.next()
if x.finished {
self.state = .Iter1Finished
return self.next()
} else self.state = .Iter0
},
.Iter1Finished => {
x = self.iter0.inner.next()
if x.finished self.state = .Iter0Finished
},
_ => {
},
}
return .(self.state == .Iter0Finished, x.val)
}
}
}

99
src/lib.hb
View file

@ -1,99 +1,2 @@
Version := struct {
major: uint,
minor: uint,
patch: uint,
}
$VERSION := Version(0, 0, 6)
Config := struct {
$DEBUG := true
$DEBUG_ASSERTIONS := false
$MIN_LOGLEVEL := log.LogLevel.Info
$debug := fn(): bool return Config.DEBUG
$debug_assertions := fn(): bool return Config.DEBUG | Config.DEBUG_ASSERTIONS
$min_loglevel := fn(): log.LogLevel {
if Config.debug() & Config.MIN_LOGLEVEL < .Debug return .Debug
return Config.MIN_LOGLEVEL
}
}
// ----------------------------------------------------
collections := @use("collections/lib.hb")
process := @use("process.hb")
result := @use("result.hb")
string := @use("string.hb")
alloc := @use("alloc/lib.hb")
hash := @use("hash/lib.hb")
rand := @use("rand/lib.hb")
math := @use("math.hb")
iter := @use("iter.hb")
target := @use("target/lib.hb")
log := @use("log.hb")
fmt := @use("fmt.hb");
.{Target} := @use("targets/lib.hb");
.{print, printf} := log;
.{Type, TypeOf} := @use("type.hb")
// ! (compiler) bug: inlining here crashes the parser. nice.
// ! (libc) (compiler) bug: NOT inlining here makes it sometimes not work
$panic := fn(message: ?[]u8): never {
if message != null log.error(message) else log.error("The program called panic.")
exit(1)
}
// ! exit, memcopy, memmove, and memset are all temporary wrapper functions
$exit := fn(code: int): never {
Target.exit(code)
die
}
$memcopy := fn(dest: @Any(), src: @Any(), size: uint): void {
if TypeOf(dest).kind() != .Pointer | TypeOf(src).kind() != .Pointer @error("memcopy requires a pointer")
Target.memcopy(@bitcast(dest), @bitcast(src), size)
}
$memmove := fn(dest: @Any(), src: @Any(), size: uint): void {
if TypeOf(dest).kind() != .Pointer | TypeOf(src).kind() != .Pointer @error("memmove requires a pointer")
Target.memmove(@bitcast(dest), @bitcast(src), size)
}
$memset := fn(dest: @Any(), src: u8, size: uint): void {
if TypeOf(dest).kind() != .Pointer @error("memset requires a pointer")
Target.memset(@bitcast(dest), src, size)
}
_qs_partition := fn($func: type, array: @Any(), start: uint, end: uint): uint {
pivot := array[end]
i := start
j := start
loop if j >= end break else {
defer j += 1
if func(array[j], pivot) {
temp := array[i]
array[i] = array[j]
array[j] = temp
i += 1
}
}
temp := array[i]
array[i] = array[end]
array[end] = temp
return i
}
/// Can sort in place if `&array` is passed rather than `array`
/// For sorting slices in place, do not pass `&slice`, pass `slice` instead.
quicksort := fn($func: type, array: @Any(), start: uint, end: uint): @TypeOf(array) {
if start >= end return array;
pivot_index := _qs_partition(func, array, start, end)
if pivot_index > 0 array = quicksort(func, array, start, pivot_index - 1)
array = quicksort(func, array, pivot_index + 1, end)
return array
}
$compare := fn(lhs: @Any(), rhs: @Any()): bool {
return lhs < rhs
}

50
src/log.hb
View file

@ -1,53 +1,21 @@
.{Config, Target, fmt} := @use("lib.hb")
.{target} := @use("lib.hb")
LogLevel := enum {
Error,
Warn,
Info,
Debug,
Trace,
.Error;
.Warn;
.Info;
.Debug;
.Trace;
}
$log := fn(level: LogLevel, str: []u8): void {
if level > Config.min_loglevel() return;
match Target.current() {
.LibC => match level {
.Error => Target.printf_str("\{1b}[31mERROR\{1b}[0m: %.*s\n\0".ptr, str.len, str.ptr),
.Warn => Target.printf_str("\{1b}[33mWARN\{1b}[0m: %.*s\n\0".ptr, str.len, str.ptr),
.Info => Target.printf_str("\{1b}[32mINFO\{1b}[0m: %.*s\n\0".ptr, str.len, str.ptr),
.Debug => Target.printf_str("\{1b}[34mDEBUG\{1b}[0m: %.*s\n\0".ptr, str.len, str.ptr),
.Trace => Target.printf_str("\{1b}[35mTRACE\{1b}[0m: %.*s\n\0".ptr, str.len, str.ptr),
},
.AbleOS => return @eca(3, 1, Target.LogMsg.(level, str.ptr, str.len), @sizeof(Target.LogMsg)),
$match target.current() {
.AbleOS => return @ecall(3, 1, target.LogEcall.(level, str.ptr, str.len), @size_of(target.LogEcall)),
}
}
// it's good enough i guess. dont write more than 4096 chars or you will explode.
print_buffer := @embed("assets/zeroed")
print := fn(any: @Any()): void {
if @TypeOf(any) == []u8 {
match Target.current() {
.LibC => Target.printf_str("%.*s\n\0".ptr, any.len, any.ptr),
.AbleOS => info(any),
}
} else {
// limits len to size of buffer - 1
len := fmt.format(print_buffer[0..@sizeof(@TypeOf(print_buffer)) - 1], any)
print_buffer[len] = 0
// ! (compiler) bug: not inlining here causes compiler panic
@inline(print, print_buffer[0..len])
}
}
printf := fn(str: []u8, any: @Any()): void {
len := fmt.format_with_str(str, print_buffer[0..@sizeof(@TypeOf(print_buffer)) - 1], any)
print_buffer[len] = 0
@inline(print, print_buffer[0..len])
}
$error := fn(message: []u8): void return log(.Error, message)
$warn := fn(message: []u8): void return log(.Warn, message)
$info := fn(message: []u8): void return log(.Info, message)
$debug := fn(message: []u8): void return log(.Debug, message)
$trace := fn(message: []u8): void return log(.Trace, message)
$trace := fn(message: []u8): void return log(.Trace, message)

106
src/main.hb
View file

@ -1,106 +0,0 @@
lily := @use("lib.hb");
Generator := struct {
n: uint = 0,
$next := fn(self: ^Self): lily.iter.IterNext(uint) {
self.n += 1
return .(false, self.n)
}
$into_iter := fn(self: Self): lily.iter.Iterator(Self) {
return .(self)
}
}
// inlining this breaks it :(
$add := fn(sum: uint, x: uint): uint {
return sum + x
}
main := fn(argc: uint, argv: []^void): uint {
// sum := Generator.{}.into_iter().take(50).fold(add, 0)
// lily.print(sum)
// // ! (libc) (compiler) bug: .collect(T) does not work.
// if lily.Target.current() != .LibC {
// str := lily.string.chars("Hello, ").intersperse(
// lily.string.chars("World!"),
// ).collect([13]u8)
// if str != null {
// lily.log.info(@as([13]u8, str)[..])
// } else {
// lily.panic("could not collect (array wrong size)")
// }
// } else {
// // yes, im cheating if you are on libc.
// // it's not my fault, blame compiler bugs. T^T
// lily.log.info("HWeolrllod,! ")
// }
// return 0
/* ! the following will ONLY work on ableos
* due to fun compiler bugs
*/
// allocator := lily.alloc.SimpleAllocator.new()
// defer allocator.deinit()
// map := lily.collections.HashMap(
// uint,
// uint,
// lily.hash.FoldHasher,
// lily.alloc.SimpleAllocator,
// ).new(&allocator)
// defer map.deinit()
// i := 0
// $loop if i == 99 * 2 break else {
// _ = map.insert(i, 0)
// _ = map.insert(i + 1, 0)
// i += 2
// }
// map.keys().for_each(lily.print)
// fun thing
// _ = map.insert("Farewell, World!", "beep boop")
// _ = map.insert("Hello, World!", "Hello!")
// _ = map.insert("Goodbye, World!", "Goodbye!")
// _ = map.insert("How do you do, World?", "Great!")
// _ = map.insert("Until next time, World!", "See you!")
// _ = map.insert("Greetings, World!", "Hi there!")
// lily.print(map.get("asdfasdf!"))
// lily.print(map.get("Hello, World!"))
// id := lily.process.fork()
// lily.print("hello, world")
// if id == 0 {
// lily.print("child")
// } else {
// lily.print("parent")
// }
a := @unwrap(lily.Target.alloc(1024))
i := 0
loop if i == 1024 break else {
defer i += 1;
*(a + i) = 'A'
// doesnt increment??? strange...
lily.print(a + i)
}
// print my screams to stdout
lily.print(a[0..250])
// Allocator := lily.alloc.ArenaAllocator
// allocator := Allocator.new()
// defer allocator.deinit()
// vec := lily.collections.Vec(uint, Allocator).new(&allocator)
// i := 0
// // ! (skill issue) bug: i > 512 causes SIGSEGV
// loop if i == 1024 break else {
// defer i += 1
// vec.push(i)
// }
// lily.print(vec.slice.len)
return 0
}

27
src/math.hb
View file

@ -1,27 +0,0 @@
.{TypeOf} := @use("lib.hb")
// ! possibly little endian only.
// ! should be fixed if we rely on libc for math
// ! ableos is always little endian so no big deal.
$abs := fn(x: @Any()): @TypeOf(x) {
T := TypeOf(x)
if T.is_int() return (x ^ x >> @bitcast(T.bits()) - 1) - (x >> @bitcast(T.bits()) - 1)
if T.is_float() return @bitcast(@as(T.USize(), @bitcast(x)) & T.bitmask() >> 1)
@error("lily.math.abs only supports integers and floats.")
}
// todo: better float min, max
$min := fn(a: @Any(), b: @TypeOf(a)): @TypeOf(a) {
T := TypeOf(a)
if T.is_int() return b + (a - b & a - b >> @bitcast(T.bits()) - 1)
if T.is_float() return @itf(a > b) * b + @itf(a <= b) * a
}
$max := fn(a: @Any(), b: @TypeOf(a)): @TypeOf(a) {
T := TypeOf(a)
if T.is_int() return a - (a - b & a - b >> @bitcast(T.bits()) - 1)
if T.is_float() return @itf(a > b) * a + @itf(a <= b) * b
}
$clamp := fn(x: @Any(), minimum: @TypeOf(x), maximum: @TypeOf(x)): @TypeOf(x) {
return max(min(x, maximum), minimum)
}

3
src/process.hb
View file

@ -1,3 +0,0 @@
.{Target} := @use("lib.hb")
$fork := fn(): uint return Target.fork()

1
src/rand/lib.hb
View file

@ -1 +0,0 @@
.{SimpleRandom} := @use("simple.hb")

65
src/rand/simple.hb
View file

@ -1,65 +0,0 @@
.{Target, TypeOf, Type} := @use("../lib.hb")
// ! NON CRYPTOGRAPHIC, TEMPORARY
SimpleRandom := struct {
seed: uint,
$new := fn(): Self return Self.(0)
$default := fn(): Self return Self.(0)
$deinit := fn(self: ^Self): void {
self.seed = 0
}
$any := fn(self: ^Self, $A: type): A {
T := Type(A)
match T.kind() {
.Slice => @error("Use SimpleRandom.fill or SimpleRandom.fill_values instead."),
.Array => @error("Use SimpleRandom.fill or SimpleRandom.fill_values instead."),
_ => {
},
}
if T.is_bool() {
a: A = idk
Target.getrandom(@bitcast(&a), 1)
return @bitcast(a & @as(u8, 1))
}
a: A = idk
Target.getrandom(@bitcast(&a), T.size())
return a
}
/// Accepts any type for min and max (as long as it is the same for both).
$range := fn(self: ^Self, min: @Any(), max: @TypeOf(min)): @TypeOf(min) {
return self.any(@TypeOf(min)) % (max - min) + min
}
/// Fills an array or slice with random bytes
$fill := fn(self: ^Self, buf: @Any()): void {
T := TypeOf(buf)
match T.kind() {
.Slice => Target.getrandom(@bitcast(buf.ptr), buf.len * T.Child().size()),
.Array => Target.getrandom(@bitcast(&buf), T.size()),
_ => @error("Can only fill bytes of Slice or Array."),
}
}
/// Fills an array or slice with random values
// ! (compiler) bug: `buf[i]` causing compiler panic here
fill_values := fn(self: ^Self, buf: @Any()): void {
T := TypeOf(buf)
match T.kind() {
.Slice => {
len := buf.len * T.Child().size()
i := 0
loop if i == len break else {
buf[i] = self.any(T.Child().This())
i += 1
}
},
.Array => {
len := T.size()
i := 0
$loop if i == len break else {
buf[i] = self.any(T.Child().This())
i += 1
}
},
_ => @error("Can only fill values of Slice or Array."),
}
}
}

16
src/result.hb
View file

@ -1,16 +0,0 @@
.{panic} := @use("lib.hb")
ResultInner := fn($T: type, $E: type): type return union {ok: T, err: E}
Result := fn($T: type, $E: type): type return struct {
inner: ResultInner(T, E),
is_ok: bool,
$ok := fn(k: T): Self return .(.{ok: k}, true)
$err := fn(k: E): Self return .(.{err: k}, false)
$unwrap := fn(self: Self): T return self.expect("Unwrap on error variant.")
$unwrap_unchecked := fn(self: Self): T return self.inner.ok
unwrap_or := fn(self: Self, v: T): T if self.is_ok return self.inner.ok else return v
unwrap_or_else := fn(self: Self, $F: type): T if self.is_ok return self.inner.ok else return F(self.inner.err)
expect := fn(self: Self, msg: []u8): T if self.is_ok return self.inner.ok else panic(msg)
}

182
src/string.hb
View file

@ -1,182 +0,0 @@
.{iter: .{Iterator, IterNext}, Type} := @use("lib.hb")
reverse := fn(str: []u8): void {
if str.len == 0 return;
j := str.len - 1
i := 0
temp := @as(u8, 0)
loop if i < j {
temp = str[i]
str[i] = str[j]
str[j] = temp
i += 1
j -= 1
} else return
}
equals := fn(lhs: []u8, rhs: []u8): bool {
if lhs.len != rhs.len return false
if lhs.ptr == rhs.ptr return true
i := 0
loop if i == lhs.len break else {
if lhs[i] != rhs[i] return false
i += 1
}
return true
}
clear := fn(str: []u8): void {
i := 0
loop if i == str.len break else {
str[i] = 0
i += 1
}
}
split_once := fn(haystack: []u8, needle: @Any()): ?struct {left: []u8, right: []u8} {
T := @TypeOf(needle)
i := 0
if T == []u8 {
if needle.len == 0 return null
loop {
if i + needle.len > haystack.len return null
if haystack[i] == needle[0] {
matches := true
n := 1
loop {
if n == needle.len break
if haystack[i + n] != needle[n] {
matches = false
break
}
n += 1
}
if matches return .(haystack[0..i], haystack[i + needle.len..])
}
i += 1
}
} else if T == u8 {
loop {
if haystack[i] == needle {
return .(haystack[0..i], haystack[i + 1..])
} else if i == haystack.len return null
i += 1
}
} else {
@error("Type of needle must be []u8 or u8.")
}
}
$split := fn(str: []u8, needle: @Any()): Iterator(struct {
str: []u8,
needle: @TypeOf(needle),
finished: bool = false,
next := fn(self: ^Self): IterNext([]u8) {
if self.finished return .(true, Type([]u8).uninit())
splits := split_once(self.str, self.needle)
if splits != null {
self.str = splits.right
return .(false, splits.left)
}
self.finished = true
return .(false, self.str)
}
}) {
T := @TypeOf(needle)
if T != []u8 & T != u8 {
@error("Type of needle must be []u8 or u8.")
}
return .(.{str, needle})
}
$chars := fn(iter: []u8): Iterator(struct {
str: []u8,
$next := fn(self: ^Self): IterNext(u8) {
tmp := IterNext(u8).(self.str.len == 0, *self.str.ptr)
self.str = self.str[1..]
return tmp
}
}) {
return .(.(iter))
}
$chars_ref := fn(iter: []u8): Iterator(struct {
str: []u8,
$next := fn(self: ^Self): IterNext(^u8) {
tmp := IterNext(^u8).(self.str.len == 0, self.str.ptr)
self.str = self.str[1..]
return tmp
}
}) {
return .(.(iter))
}
count := fn(haystack: []u8, needle: @Any()): uint {
T := @TypeOf(needle)
i := 0
c := 0
if T == []u8 {
if needle.len == 0 return null
loop {
if i + needle.len > haystack.len return c
if haystack[i] == needle[0] {
matches := true
n := 1
loop {
if n == needle.len break
if haystack[i + n] != needle[n] {
matches = false
break
}
n += 1
}
if matches c += 1
}
i += 1
}
} else if T == u8 {
loop {
if haystack[i] == needle c += 1 else if i == haystack.len return c
i += 1
}
} else {
@error("Type of needle must be []u8 or u8.")
}
}
left_trim := fn(str: []u8, sub: []u8): []u8 {
i := 0
if str[0] == sub[0] {
loop if i == sub.len {
return str[i..str.len]
} else if str[i] != sub[i] | i == str.len {
break
} else {
i += 1
}
}
return str
}
right_trim := fn(str: []u8, sub: []u8): []u8 {
i := 0
if str[str.len - 1] == sub[sub.len - 1] {
loop if i == sub.len {
return str[0..str.len - i]
} else if str[str.len - i - 1] != sub[sub.len - i - 1] | i == str.len {
break
} else {
i += 1
}
}
return str
}
trim := fn(str: []u8, sub: []u8): []u8 {
return right_trim(left_trim(str, sub), sub)
}

52
src/target/ableos.hb Normal file
View file

@ -0,0 +1,52 @@
.{LogLevel} := @use("../lib.hb").log
func := fn(): uint {
return 0
}
LogEcall := struct align(1){.level: LogLevel; .str_ptr: ^u8; .str_len: uint}
$page_len := fn(): uint {
return 4096
}
$pages := fn(len: uint): uint {
return (len + page_len() - 1) / page_len()
}
AllocEcall := struct align(1){.pad: u8; .pages_new: uint; .zeroed: bool}
$alloc := fn(len: uint): ?^u8 {
return @ecall(3, 2, AllocEcall.(0, pages(len), false), @size_of(AllocEcall))
}
$alloc_zeroed := fn(len: uint): ?^u8 {
return @ecall(3, 2, AllocEcall.(0, pages(len), true), @size_of(AllocEcall))
}
ReallocEcall := struct align(1){.pad: u8; .pages_old: uint; .pages_new: uint; .ptr_old: ^u8}
$realloc := fn(ptr_old: ^u8, len_old: uint, len_new: uint): ?^u8 {
return @ecall(3, 2, ReallocEcall.(7, pages(len_old), pages(len_new), ptr_old), @size_of(ReallocEcall))
}
DeallocEcall := struct align(1){.pad: u8; .pages: uint; .ptr: ^u8}
$dealloc := fn(ptr: ^u8, len: uint): void {
@ecall(3, 2, DeallocEcall.(1, pages(len), ptr), @size_of(DeallocEcall))
}
CopyEcall := struct align(1){.pad: u8; .len: uint; .src: ^u8; .dest: ^u8}
$memcopy := fn(dest: ^u8, src: ^u8, len: uint): void {
@ecall(3, 2, CopyEcall.(4, len, src, dest), @size_of(CopyEcall))
}
$memmove := fn(dest: ^u8, src: ^u8, len: uint): void {
@ecall(3, 2, CopyEcall.(6, len, src, dest), @size_of(CopyEcall))
}
SetEcall := struct align(1){.pad: u8; .count: uint; .len: uint; .src: ^u8; .dest: ^u8}
$memcopy := fn(dest: ^u8, src: u8, len: uint): void {
@ecall(3, 2, SetEcall.(4, len, 1, &src, dest), @size_of(SetEcall))
}
$exit := fn(code: u8): void {
}
$fill_rand := fn(dest: ^u8, len: uint): void @ecall(3, 4, dest, len)
$fork := fn(): uint return @ecall(3, 7)

19
src/target/lib.hb Normal file
View file

@ -0,0 +1,19 @@
.{func} := Lib(current())
Target := enum {
.AbleOS;
}
$current := fn(): Target {
$if @target("ableos") {
return .AbleOS
} else {
@error("Unknown Target")
}
}
$Lib := fn(target: Target): type {
$match target {
.AbleOS => return @use("ableos.hb"),
}
}

51
src/targets/ableos-spec.md
View file

@ -1,51 +0,0 @@
# documenting the used features of the AbleOS spec
> [!Important]
> this does not apply to all hbvm targets. it applies to ableos specifically. other hbvm targets will have different ecalls, or even no ecalls. for an example of another project using hbvm, see [depell](https://depell.mlokis.tech/) (dependency hell), a website created by mlokis, the main programmer of hblang, that runs hblang programs, in hbvm, in wasm.
## how do ecalls work?
ecalls are comprised of a series of values, with each consecutive one representing the value of a vm register from 1-255 (the 0 register is reserved). `ecall a b c` fills the first three registers with the values `a`, `b`, and `c` respectively. the ecall handler reads these values and performs a kernel operation based on them.
## how is this formatted?
all registers are followed by parethesis with their purpose. the `message` section is actually a pointer to a single location in memory, taking a single register. the following register is always the size of this message. this is omitted for brevity.<br>
`ecall register(purpose), ..., register(purpose), message_bytes:type, ..., message_bytes:type`
## more info?
read [here](https://git.ablecorp.us/AbleOS/ableos/src/branch/master/kernel/src/holeybytes/ecah.rs) for the full set of ecalls and buffer ids.
### `lily.log`:
log: `ecall 3(buf), 1(log), loglevel:u8, string:*const u8, strlen:u64`<br>
> formats and then copies `strlen` of `string` into the serial output
### `lily.Target.AbleOS`:
alloc: `ecall 3(buf), 2(mem), 0(alloc), page_count:u64, zeroed:bool=false`
> returns `Option<*mut u8>` to an available contiguous chunk of memory, sized in `4096` byte (align `8`) pages. it is undefined behaviour to use size zero.
alloc_zeroed: `ecall 3(buf), 2(mem), 0(alloc), page_count:u64, zeroed:bool=true`<br>
> same as alloc, except filled with zeroes.
realloc: `ecall 3(buf), 2(mem), 7(realloc), page_count:u64, page_count_new:u64, ptr:*const u8, ptr_new:*const u8`<br>
> resizes an existing contiguous chunk of memory allocated via `alloc`, `alloc_zeroed`, or `realloc`. contents remain the same. it is undefined behaviour to use size zero or a `null` pointer. returns a new `Option<*mut u8>` after resizing.
dealloc: `ecall 3(buf), 2(mem), 1(dealloc), page_count:u64, ptr:*const u8`<br>
> releases an existing contiguous chunk of memory allocated via `alloc`, `alloc_zeroed`, or `realloc`. it is undefined behaviour to use size zero or a `null` pointer.
memcopy: `ecall 3(buf), 2(mem), 4(memcopy), size:u64, src:*const u8, dest:*const u8`<br>
> copies `size` of `src` into `dest`. `src` and `dest` must not be overlapping. it is undefined behaviour to use size zero or a `null` pointer.
memset: `ecall 3(buf), 2(mem), 5(memset), count:u64, size:u64, src:*const u8, dest:*mut u8`<br>
> consecutively copies `size` of `src` into `dest` a total of `count` times. `src` and `dest` must not be overlapping. it is undefined behaviour to use size zero or a `null` pointer.
memmove: `ecall 3(buf), 2(mem), 6(memmove), size:u64, src:*const u8, dest:*mut u8`<br>
> copies `size` of `src` into a buffer, then from the buffer into `dest`. `src` and `dest` can be overlapping. it is undefined behaviour to use size zero or a `null` pointer.
getrandom: `ecall 3(buf) 4(rand) dest:*mut u8, size:u64`
> fills `dest` with `size` bytes of random cpu entropy.
## ecall numbers (u8)
3. send a message to a buffer
## buffer ids (uint)
1. logging service
2. memory service
4. random service

51
src/targets/ableos.hb
View file

@ -1,51 +0,0 @@
.{LogLevel} := @use("../lib.hb").log
$page_size := fn(): uint {
return 4096
}
LogMsg := packed struct {level: LogLevel, string: ^u8, strlen: uint}
$calculate_pages := fn(size: uint): uint {
return (size + page_size() - 1) / page_size()
}
AllocMsg := packed struct {a: u8, count: uint, zeroed: bool}
$alloc := fn(size: uint): ?^u8 {
return @eca(3, 2, &AllocMsg.(0, calculate_pages(size), false), @sizeof(AllocMsg))
}
$alloc_zeroed := fn(size: uint): ?^u8 {
return @eca(3, 2, &AllocMsg.(0, calculate_pages(size), true), @sizeof(AllocMsg))
}
ReallocMsg := packed struct {a: u8, count: uint, count_new: uint, ptr: ^u8}
$realloc := fn(ptr: ^u8, size: uint, size_new: uint): ?^u8 {
return @eca(3, 2, &ReallocMsg.(7, calculate_pages(size), calculate_pages(size_new), ptr), @sizeof(ReallocMsg))
}
FreeMsg := packed struct {a: u8, count: uint, ptr: ^u8}
$dealloc := fn(ptr: ^u8, size: uint): void {
return @eca(3, 2, &FreeMsg.(1, calculate_pages(size), ptr), @sizeof(FreeMsg))
}
CopyMsg := packed struct {a: u8, count: uint, src: ^u8, dest: ^u8}
$memcopy := fn(dest: ^u8, src: ^u8, size: uint): void {
return @eca(3, 2, &CopyMsg.(4, size, src, dest), @sizeof(CopyMsg))
}
SetMsg := packed struct {a: u8, count: uint, size: uint, src: ^u8, dest: ^u8}
$memset := fn(dest: ^u8, src: u8, size: uint): void {
return @eca(3, 2, &SetMsg.(5, size, 1, @bitcast(&src), dest), @sizeof(SetMsg))
}
$memmove := fn(dest: ^u8, src: ^u8, size: uint): void {
return @eca(3, 2, &CopyMsg.(6, size, src, dest), @sizeof(CopyMsg))
}
$getrandom := fn(dest: ^u8, size: uint): void return @eca(3, 4, dest, size)
$exit := fn(code: int): void {
}
$fork := fn(): uint return @eca(3, 7)

26
src/targets/lib.hb
View file

@ -1,26 +0,0 @@
Target := enum {
LibC,
AbleOS,
ableos := @use("ableos.hb")
libc := @use("libc.hb")
$current := fn(): Self {
// This captures all HBVM targets, but for now only AbleOS is supported
if @target("*-virt-unknown") {
return .AbleOS
}
// Assume that unknown targets have libc
return .LibC
}
$Lib := fn(self: Self): type {
match self {
.AbleOS => return Self.ableos,
.LibC => return Self.libc,
}
}
/* todo: reorganise these */;
.{alloc, alloc_zeroed, realloc, dealloc, memmove, memcopy, memset, exit, getrandom, page_size, calculate_pages, fork} := Self.Lib(Self.current());
.{printf_str} := Self.Lib(.LibC);
.{LogMsg} := Self.Lib(.AbleOS)
}

70
src/targets/libc.hb
View file

@ -1,70 +0,0 @@
alloc := fn(size: uint): ?^u8 @import("malloc")
alloc_zeroed := fn(size: uint): ?^u8 @import("calloc")
realloc_c := fn(ptr: ^u8, size: uint): ?^u8 @import("realloc")
dealloc_c := fn(ptr: ^u8): void @import("free")
memmove := fn(dest: ^u8, src: ^u8, size: uint): void @import()
memcopy := fn(dest: ^u8, src: ^u8, size: uint): void @import("memcpy")
memset := fn(dest: ^u8, src: u8, size: uint): void @import()
exit := fn(code: int): void @import()
printf_str := fn(str0: ^u8, strlen: uint, str1: ^u8): void @import("printf")
getrandom := fn(dest: ^u8, size: uint): void @import()
fork := fn(): uint @import()
$realloc := fn(ptr: ^u8, size: uint, size_new: uint): ?^u8 {
return realloc_c(ptr, size)
}
$dealloc := fn(ptr: ^u8, size: uint): void {
return dealloc_c(ptr)
}
// temp
$page_size := fn(): uint {
return 4096
}
// also temp
$calculate_pages := fn(size: uint): uint {
return (size + page_size() - 1) / page_size()
}
// mmap := fn(ptr: ?^u8, len: uint, prot: u32, flags: u32, fd: u32, offset: uint): ?^u8 @import()
// munmap := fn(ptr: ^u8, len: uint): void @import()
// mremap := fn(ptr: ^u8, old_len: uint, new_len: uint, flags: u32): ?^u8 @import()
// getpagesize := fn(): u32 @import()
// LILY_POSIX_PROT_READWRITE := fn(): u32 @import()
// LILY_POSIX_MAP_SHAREDANONYMOUS := fn(): u32 @import()
// LILY_POSIX_MREMAP_MAYMOVE := fn(): u32 @import()
// causes segfault. nice.
// $alloc := fn(len: uint): ?^u8 return mmap(
// null,
// len,
// LILY_POSIX_PROT_READWRITE(),
// LILY_POSIX_MAP_SHARED(),
// -1,
// 0,
// )
// alloc := alloc_zeroed
// $alloc_zeroed := fn(len: uint): ?^u8 return mmap(
// null,
// len,
// LILY_POSIX_PROT_READWRITE(),
// LILY_POSIX_MAP_SHAREDANONYMOUS(),
// -1,
// 0,
// )
// $realloc := fn(ptr: ^u8, len: uint, len_new: uint): ?^u8 return mremap(
// ptr,
// len,
// len_new,
// LILY_POSIX_MREMAP_MAYMOVE(),
// )
// $dealloc := fn(ptr: ^u8, len: uint): void munmap(ptr, len)
// $page_size := fn(): uint return getpagesize()
// $calculate_pages := fn(size: uint): uint {
// return (size + page_size() - 1) / page_size()
// }

105
src/type.hb
View file

@ -1,105 +0,0 @@
RawKind := enum {
Builtin,
Struct,
Tuple,
Enum,
Union,
Pointer,
Slice,
Optional,
Function,
Template,
Global,
Constant,
Module,
}
Kind := enum {
Builtin,
Struct,
Tuple,
Enum,
Union,
Pointer,
Slice,
Array,
Optional,
Function,
Template,
Global,
Constant,
Module,
}
TypeOf := fn(T: @Any()): type return Type(@TypeOf(T))
Type := fn($T: type): type return struct {
// ! no way of representing arbitrary size integers yet
USize := fn(): type {
if @sizeof(T) == 1 return u8 else if @sizeof(T) == 2 return u16 else if @sizeof(T) == 4 return u32 else return uint
}
Child := fn(): type {
return Type(@ChildOf(T))
}
This := fn(): type {
return T
}
$name := fn(): []u8 {
return @nameof(T)
}
$is_bool := fn(): bool {
return T == bool
}
$is_unsigned_int := fn(): bool {
return T == uint | T == u8 | T == u16 | T == u32
}
$is_signed_int := fn(): bool {
return T == int | T == i8 | T == i16 | T == i32
}
$is_int := fn(): bool {
return Self.is_unsigned_int() | Self.is_signed_int()
}
$is_float := fn(): bool {
return T == f32 | T == f64
}
$len := fn(): uint {
return @lenof(T)
}
$align := fn(): uint {
return @alignof(T)
}
$size := fn(): uint {
return @sizeof(T)
}
$bits := fn(): Self.USize() {
return @sizeof(T) << 3
}
$bitmask := fn(): Self.USize() {
return -1
}
$raw_kind := fn(): RawKind {
return @bitcast(@kindof(T))
}
$kind := fn(): Kind {
if Self.raw_kind() == .Slice {
if []@ChildOf(T) == T return .Slice else return .Array
} else if @kindof(T) > @bitcast(Kind.Slice) {
return @bitcast(@kindof(T) + 1)
} else return @bitcast(Self.raw_kind())
}
/// ! There are no guarantees that this value is zeroed for builtins, enums, unions, structs, arrays, or tuples.
$uninit := fn(): T {
match Self.kind() {
.Pointer => return @bitcast(0),
.Slice => return Type(^Self.Child().This()).uninit()[0..0],
.Array => return idk,
.Builtin => return idk,
.Struct => return idk,
.Tuple => return idk,
.Union => return idk,
.Enum => return idk,
.Optional => return null,
_ => @error("Type(", T, ").uninit() does not make sense."),
}
}
}