Returns a borrowed argv[index] pointer captured by the runtime.

Returns the argc value captured by the generated runtime entrypoint.

Owned child-process builder implemented in Ignis std.

The builder keeps owned program, argument, environment, and cwd state in nongeneric storage so the std module can drive POSIX fork/execvp directly through std::libc without relying on dedicated runtime helpers.

Example

import Path from "std::path";
import Process from "std::process";
import String from "std::string";
import Vector from "std::vector";

let mut extra: Vector<String> = Vector::new<String>();
extra.push(String::create("-c"));
extra.push(String::create("printf done"));

let mut command: Process::Command = Process::Command::new("/bin/sh");
command.args(extra);
command.env("IGNIS_CHILD", "1");
command.cwd(&Path::PathBuf::create("/tmp"));

match (command.run()) {
  Result::OK(status) -> {
    let ok: boolean = status.success;
  },
  Result::ERROR(_) -> {},
};

Normalized child-process status derived from a POSIX wait status.

raw preserves the host wait status. code contains a shell-like exit code: regular exits use the child exit code and signal exits use 128 + signal. success is true only when the child exited with code 0.

Captured child-process output plus exit status.

Example

import Process from "std::process";
import String from "std::string";

let command: Process::Command = Process::Command::new("/bin/echo");
match (command.output()) {
  Result::OK(output) -> {
    let status: Process::ExitStatus = output.status();
    let stdout: String = output.stdout();
  },
  Result::ERROR(_) -> {},
};

Returns the host startup argument count, including argv[0].

The count comes from the runtime bootstrap created by the compiler’s C main wrapper. It is the same count used by Process::args.

Returns

Number of startup arguments captured by the runtime, including argv[0].

Invariants

argCount() should match Process::args().length() as long as runtime initialization happened before the call and the runtime bridge remains unchanged.

Example

import Process from "std::process";

let count: i32 = Process::argCount();
let hasProgramName: boolean = count > 0;

Returns owned copies of the startup arguments, including argv[0].

The returned vector owns every string. Mutating or storing the returned values is safe because they no longer borrow from the runtime argv array.

Ordering

The result preserves host argv order exactly:

  args()[0] -> argv[0]  // program/test binary path
  args()[1] -> argv[1]
  args()[2] -> argv[2]

The std test runner invokes individual tests through its own harness, so argv[0] is the generated std test binary in that context.

Returns

A vector with Process::argCount() entries. The first entry is the program path or command name as supplied by the host process launcher.

Example

import Process from "std::process";

let args = Process::args();
let hasUserArg: boolean = args.length() > 1;

Convenience helper mirroring common builder-style construction.

Example

import Process from "std::process";

let mut command: Process::Command = Process::command("/bin/echo");
command.arg("hello");

Returns the current process identifier.

This is the host PID returned by getpid(2) on POSIX platforms. The value is useful for diagnostics, logs, temporary file names, and process-aware integration tests.

Returns

Positive host process identifier for the currently running test or program.

Notes

PIDs are host resources. They are not deterministic between runs and should only be used for diagnostics, uniqueness, or sanity checks.

Example

import Process from "std::process";

let pid: i32 = Process::id();
let valid: boolean = pid > 0;

Returns the parent process identifier.

This is the host parent PID returned by getppid(2). Parent process IDs can change if the original parent exits and the process is reparented by the operating system.

Returns

Host process identifier for the current process parent.

Notes

POSIX can reparent processes when the original parent exits. Do not use this value as a stable identity across long-running programs.

Example

import Process from "std::process";

let parent: i32 = Process::parentId();
let hasParent: boolean = parent > 0;

Executes command through the host shell and returns the raw host status.

The command is passed to the platform C library system(3). The shell is responsible for parsing, expansion, redirection, PATH lookup, and process creation. The returned value is the raw host status, not a normalized exit code.

Security

Avoid building command from untrusted input. Shell metacharacters can change the executed program or add additional commands.

Arguments

• command: shell command text passed directly to system(3).

Returns

Raw host status returned by the C library. On POSIX this is a wait status, not just the child exit code.

Status Encoding

A command that exits with code 1 may return an encoded value such as 256, depending on the platform. Prefer Process::Command::run when you need the normalized Process::ExitStatus view.

Example

import Process from "std::process";

let status: i32 = Process::system("true");
let succeededExactly: boolean = status == 0;