parse const decls

std/io/file.hon

@@ -1,124 +1,124 @@
 import "@ffi/c"
 
 File :: struct {
-	io Io
-	handle Handle
+    io Io
+    handle Handle
 }
 
 FileMode :: enum {
-	read_only
-	write_only
-	read_write
+    read_only
+    write_only
+    read_write
 }
 
 OpenError :: enum {
-	open_failed
+    open_failed
 }
 
 CloseError :: enum {
-	close_failed
+    close_failed
 }
 
 open proc(io Io, path [;0]u8, mode FileMode) File ! OpenError {
-	handle Handle :: try io.vtable.open(io.context, path, mode)
-	return File{ io = io, handle = handle }
+    handle Handle :: try io.vtable.open(io.context, path, mode)
+    return File{ io = io, handle = handle }
 }
 
 close proc(file File) void ! CloseError {
-	try file.io.vtable.close(file.io.context, file.handle)
+    try file.io.vtable.close(file.io.context, file.handle)
 }
 
 reader proc(file File) Reader {
-	return Reader {
-		context = file.io.context,
-		handle = file.handle,
-		read = file.io.vtable.read,
-	}
+    return Reader {
+        context = file.io.context,
+        handle = file.handle,
+        read = file.io.vtable.read,
+    }
 }
 
 writer proc(file File) Writer {
-	return Writer {
-		context = file.io.context,
-		handle = file.handle,
-		write = file.io.vtable.write,
-	}
+    return Writer {
+        context = file.io.context,
+        handle = file.handle,
+        write = file.io.vtable.write,
+    }
 }
 
 hide system_read proc(_ ?@mut anyopaque, handle Handle, buffer []mut u8) usize ! ReadError {
-	request usize = buffer.len
-	maximum usize :: usize(maxval!(c_long))
-	if (request > maximum) request = maximum
+    request usize = buffer.len
+    maximum usize :: usize(maxval!(c_long))
+    if (request > maximum) request = maximum
 
-	while true {
-		count c_long :: c.read(handle.file_desc, buffer.ptr, c_ulong(request))
-		if (count >= 0) return usize(count)
+    while true {
+        count c_long :: c.read(handle.file_desc, buffer.ptr, c_ulong(request))
+        if (count >= 0) return usize(count)
 
-		errno c_int :: c.__error()?^
-		if (errno == c.EINTR) continue
-		if (errno == c.EBADF) return .not_open_for_reading
-		return .read_failed
-	}
+        errno c_int :: c.__error()?^
+        if (errno == c.EINTR) continue
+        if (errno == c.EBADF) return .not_open_for_reading
+        return .read_failed
+    }
 }
 
 hide system_write proc(_ ?@mut anyopaque, handle Handle, bytes []u8) usize ! WriteError {
-	request usize = bytes.len
-	maximum usize :: usize(maxval!(c_long))
-	if (request > maximum) request = maximum
+    request usize = bytes.len
+    maximum usize :: usize(maxval!(c_long))
+    if (request > maximum) request = maximum
 
-	while true {
-		count c_long :: c.write(handle.file_desc, bytes.ptr, c_ulong(request))
-		if (count >= 0) return usize(count)
+    while true {
+        count c_long :: c.write(handle.file_desc, bytes.ptr, c_ulong(request))
+        if (count >= 0) return usize(count)
 
-		errno c_int :: c.__error()?^
-		if (errno == c.EINTR) continue
-		if (errno == c.EBADF) return .not_open_for_writing
-		return .write_failed
-	}
+        errno c_int :: c.__error()?^
+        if (errno == c.EINTR) continue
+        if (errno == c.EBADF) return .not_open_for_writing
+        return .write_failed
+    }
 }
 
 hide system_open proc(_ ?@mut anyopaque, path [;0]u8, mode FileMode) Handle ! OpenError {
-	flags c_int = c.O_RDONLY
-	match mode {
-		.read_only: flags = c.O_RDONLY
-		.write_only: flags = c.O_WRONLY
-		.read_write: flags = c.O_RDWR
-	}
-	while true {
-		fd c_int :: c.open(ptrcast!(c_char, path.ptr), flags)
-		if (fd >= 0) return Handle{ file_desc = fd }
-		if (c.__error()?^ != c.EINTR) return .open_failed
-	}
+    flags c_int = c.O_RDONLY
+    match mode {
+        .read_only: flags = c.O_RDONLY
+        .write_only: flags = c.O_WRONLY
+        .read_write: flags = c.O_RDWR
+    }
+    while true {
+        fd c_int :: c.open(ptrcast!(c_char, path.ptr), flags)
+        if (fd >= 0) return Handle{ file_desc = fd }
+        if (c.__error()?^ != c.EINTR) return .open_failed
+    }
 }
 
 hide system_close proc(_ ?@mut anyopaque, handle Handle) void ! CloseError {
-	if (c.close(handle.file_desc) != 0) return .close_failed
+    if (c.close(handle.file_desc) != 0) return .close_failed
 }
 
 hide system_stdin proc(_ ?@mut anyopaque) Handle {
-	return Handle{ file_desc = c_int(Stream.stdin) }
+    return Handle{ file_desc = c_int(Stream.stdin) }
 }
 
 hide system_stdout proc(_ ?@mut anyopaque) Handle {
-	return Handle{ file_desc = c_int(Stream.stdout) }
+    return Handle{ file_desc = c_int(Stream.stdout) }
 }
 
 hide system_stderr proc(_ ?@mut anyopaque) Handle {
-	return Handle{ file_desc = c_int(Stream.stderr) }
+    return Handle{ file_desc = c_int(Stream.stderr) }
 }
 
 hide system_vtable IoVTable :: IoVTable {
-	read = system_read,
-	write = system_write,
-	open = system_open,
-	close = system_close,
-	stdin = system_stdin,
-	stdout = system_stdout,
-	stderr = system_stderr,
+    read = system_read,
+    write = system_write,
+    open = system_open,
+    close = system_close,
+    stdin = system_stdin,
+    stdout = system_stdout,
+    stderr = system_stderr,
 }
 
 hide system proc() Io {
-	return Io {
-		context = null,
-		vtable = &system_vtable,
-	}
+    return Io {
+        context = null,
+        vtable = &system_vtable,
+    }
 }