silk.system.host_input_native.

import silk.mem.allocator { Allocator, OutOfMemoryError }
import silk.collections.bytes { Bytes }
import silk.core.effect { Effect }
import silk.system.host_input { HostInput, HostInputError }
import silk.platform.native.host_input { NativeHostInput }
import silk.system.host_input_native { OsHostInput }

effect fn program() -> i32
  ! HostInputError | OutOfMemoryError
  ? &mut Allocator {
  // A snapshot of the environment, with no arguments. No other code changes the environment now.
  let snapshot = run unsafe NativeHostInput.environmentSnapshot()
  let mut inputs = OsHostInput.make(move snapshot)
  let count = run HostInput.argumentCount() |> Effect.provideMut<HostInput>(&mut inputs)
  let directory = run HostInput.workingDirectory() |> Effect.provideMut<HostInput>(&mut inputs)

  // The working directory is an absolute path.
  let path = Bytes.asSlice(&directory)
  if count != 0 || path.length == 0 || path[0] != 47 {
    return 1
  }
  return 0
}

effect fn failed<E>(error: E) -> i32 {
  drop error
  return 1
}

pub fn main() -> i32 {
  let mut allocator = Allocator.systemAllocatorProvider()
  return run Effect.catchAll(program(), failed) |> Effect.provideMut<Allocator>(&mut allocator)
}

pub struct OsHostInput

impl OsHostInput

pub fn make(inputs: NativeHostInput) -> OsHostInput

impl HostInput for OsHostInput

argumentCount: OsHostInput.argumentCount

argument: OsHostInput.argument

variable: OsHostInput.variable

workingDirectory: OsHostInput.workingDirectory