Environment variables

Environment variables
You are encouraged to solve this task according to the task description, using any language you may know.

Task

Show how to get one of your process's environment variables.

The available variables vary by system;   some of the common ones available on Unix include:

•   PATH
•   HOME
•   USER

11l

print(os:getenv(‘HOME’))

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux

/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program varenvir64.s   */

/***********************/
/* Constantes    */
/***********************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"

/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros64.inc"            @ for developer debugging

/***********************/
/* Initialized data    */  
/***********************/
.data
szMessDebutPgm:      .asciz "Program 64 bits start. \n"
szMessFinOK:         .asciz "Program normal end. \n"
szCarriageReturn:    .asciz "\n"
szmessresUser:       .asciz "result for USER :"
szmessresHome:       .asciz "result for HOME :"
szmessresPath:       .asciz "result for PATH :"
szVarRech:           .asciz  "USER="
                     .equ LGVARRECH,  . - szVarRech  - 1 // car zero final
szVarRech1:          .asciz  "HOME="
                     .equ LGVARRECH1,  . - szVarRech1  - 1 // car zero final
szVarRech2:          .asciz  "PATH="
                     .equ LGVARRECH2,  . - szVarRech2  - 1 // car zero final
/***********************/
/* UnInitialized data */
/***********************/
.bss 
.align 4
/***********************/
/*  code section       */
/***********************/
.text
.global main 
main:                               // entry of program
    ldr x0,qAdrszMessDebutPgm
    bl affichageMess 
    mov fp,sp                       //  fp <- start address
    mov x0,fp

                                    // variable search USER
    ldr x2,[fp]                     // number param
    add x2,x2,#2
    ldr x1,qAdrszVarRech
1:
    ldr x0,[fp,x2,lsl #3]           // load variable address
    cmp x0,#0                       // end ?
    beq 2f
    mov x4,x0                       
    bl searchSubBeginString         // search variable name 
    cmp x0,#-1                      // no find ?
    cinc x2,x2,eq
    beq 1b
    ldr x0,qAdrszmessresUser
    bl affichageMess
    add x0,x4,#LGVARRECH
    bl affichageMess                // display result 
    ldr x0,qAdrszCarriageReturn
    bl affichageMess 
    
2: 
    ldr x2,[fp]                     // search variable HOME
    add x2,x2,#2
    ldr x1,qAdrszVarRech1
3:
    ldr x0,[fp,x2,lsl #3]
    cmp x0,#0
    beq 4f
    mov x4,x0
    bl searchSubBeginString
    cmp x0,#-1
    cinc x2,x2,eq
    beq 3b
    ldr x0,qAdrszmessresHome
    bl affichageMess
    add x0,x4,#LGVARRECH
    bl affichageMess 
    ldr x0,qAdrszCarriageReturn
    bl affichageMess 
    
4: 
    ldr x2,[fp]                 // search variable PATH
    add x2,x2,#2
    ldr x1,qAdrszVarRech2
5:
    ldr x0,[fp,x2,lsl #3]
    cmp x0,#0
    beq 6f
    mov x4,x0
    bl searchSubBeginString
    cmp x0,#-1
    cinc x2,x2,eq
    beq 5b
    ldr x0,qAdrszmessresPath
    bl affichageMess
    add x0,x4,#LGVARRECH
    bl affichageMess 
    ldr x0,qAdrszCarriageReturn
    bl affichageMess 
    
6: 
    ldr x0,qAdrszMessFinOK
    bl affichageMess
100:                                    // standard end of the program
    mov x0, #0                          // return code
    mov x8,EXIT 
    svc 0                               // perform the system call

qAdrszMessDebutPgm:       .quad szMessDebutPgm
qAdrszMessFinOK:          .quad szMessFinOK
qAdrszCarriageReturn:     .quad szCarriageReturn
qAdrszVarRech:            .quad szVarRech
qAdrszVarRech1:           .quad szVarRech1
qAdrszVarRech2:           .quad szVarRech2
qAdrszmessresUser:        .quad szmessresUser
qAdrszmessresPath:        .quad szmessresPath
qAdrszmessresHome:        .quad szmessresHome
/******************************************************************/
/*   search a substring at the string  beguining                          */ 
/******************************************************************/
/* r0 contains the address of the input string */
/* r1 contains the address of substring */
/* r0 returns index of substring in string or -1 if not found */
searchSubBeginString:
    stp x1,lr,[sp,-16]!       // save registers
    stp x2,x3,[sp,-16]!
    stp x4,x5,[sp,-16]!
    mov x2,#0                // counter byte input string
    mov x3,#0                // counter byte string 
1:
    ldrb w4,[x1,x3]
    ldrb w5,[x0,x2]          // load byte string 
    cmp x5,#0
    beq 3f
    cmp x4,#0                // zero final ?
    csel x0,xzr,x0,eq        // yes string find in position 0
    beq 100f
    cmp x5,x4                // compare character 
    beq 2f
    mov x0,#-1               // no return  no find
    b 100f
2:
    add x2,x2,#1             // and increment counter byte
    add x3,x3,#1             // and increment 
    b 1b                     // and loop
3:     
    mov x2,-1                // 
    cmp x4,#0
    mov x0,#-1               // yes returns no find
    bne 100f
    mov x0,#0                // string find in position 0
100:
    ldp x4,x5,[sp],16    
    ldp x2,x3,[sp],16
    ldp x1,lr,[sp],16        // restaur registers
    ret 

/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"

Output:

Program 64 bits start.
result for USER :u0_a420
result for HOME :/data/data/com.termux/files/home
result for PATH :/data/data/com.termux/files/usr/bin:/data/data/com.termux/files/home/asm64/scripts:.:/data/data/com.termux/files/home/asm64/scripts:.
Program normal end.

Ada

Print a single environment variable.

with Ada.Environment_Variables; use Ada.Environment_Variables;
with Ada.Text_Io; use Ada.Text_Io;

procedure Print_Path is
begin
   Put_Line("Path : " & Value("PATH"));
end Print_Path;

Print all environment variable names and values.

with Ada.Environment_Variables; use Ada.Environment_Variables;
with Ada.Text_Io; use Ada.Text_Io;

procedure Env_Vars is
   procedure Print_Vars(Name, Value : in String) is
   begin
      Put_Line(Name & " : " & Value);
   end Print_Vars;
begin
   Iterate(Print_Vars'access);
end Env_Vars;

Alternative version using Matreshka

Uses Matreshka.

with Ada.Wide_Wide_Text_IO;

with League.Application;
with League.Strings;

procedure Main is

   function "+"
    (Item : Wide_Wide_String) return League.Strings.Universal_String
       renames League.Strings.To_Universal_String;

begin
   Ada.Wide_Wide_Text_IO.Put_Line
    (League.Application.Environment.Value (+"HOME").To_Wide_Wide_String);
end Main;

ALGOL 68

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386 - getenv is not part of the standard's prelude

print((getenv("HOME"), new line))

APL

      ⎕ENV 'HOME'
 HOME /home/russtopia

AppleScript

Invoking Finder

tell application "Finder" to get name of home

Invoking Terminal

"HOME : " & (do shell script "echo $HOME" & ", PATH : " & (do shell script "echo $PATH" & ", USER : " & (do shell script "echo $USER")))

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux

/* ARM assembly Raspberry PI  */
/*  program commandLine.s   */
/* REMARK 1 : this program use routines in a include file 
   see task Include a file language arm assembly 
   for the routine affichageMess conversion10 
   see at end of this program the instruction include */

/***********************/
/* Constantes    */
/***********************/
.include "../constantes.inc"


/*******************************************/
/*   Macros                              */
/*******************************************/
//.include "../../ficmacros32.inc"            @ for developer debugging

/***********************/
/* Initialized data    */  
/***********************/
.data
szMessDebutPgm:      .asciz "Program 32 bits start. \n"
szMessFinOK:         .asciz "Program normal end. \n"
szCarriageReturn:    .asciz "\n"
szmessresUser:       .asciz "result for USER :"
szmessresHome:       .asciz "result for HOME :"
szmessresPath:       .asciz "result for PATH :"
szVarRech:           .asciz  "USER="
                     .equ LGVARRECH,  . - szVarRech  - 1 @ car zero final
szVarRech1:          .asciz  "HOME="
                     .equ LGVARRECH1,  . - szVarRech1  - 1 @ car zero final
szVarRech2:          .asciz  "PATH="
                     .equ LGVARRECH2,  . - szVarRech2  - 1 @ car zero final
/***********************/
/* UnInitialized data */
/***********************/
.bss 
.align 4
/***********************/
/*  code section       */
/***********************/
.text
.global main 
main:                               @ entry of program
    ldr r0,iAdrszMessDebutPgm
    bl affichageMess 
    mov fp,sp                       @  fp <- start address
    mov r0,fp

                                    @ variable search USER
    ldr r2,[fp]                     @ number param
    add r2,r2,#2
    ldr r1,iAdrszVarRech
1:
    ldr r0,[fp,r2,lsl #2]           @ load variable address
    cmp r0,#0                       @ end ?
    beq 2f
    mov r4,r0                       
    bl searchSubBeginString         @ search variable name 
    cmp r0,#-1                      @ no find ?
    addeq r2,#1
    beq 1b
    ldr r0,iAdrszmessresUser
    bl affichageMess
    add r0,r4,#LGVARRECH
    bl affichageMess                @ display result 
    ldr r0,iAdrszCarriageReturn
    bl affichageMess 
    
2: 
    ldr r2,[fp]                     @ search variable HOME
    add r2,r2,#2
    ldr r1,iAdrszVarRech1
3:
    ldr r0,[fp,r2,lsl #2]
    cmp r0,#0
    beq 4f
    mov r4,r0
    bl searchSubBeginString
    cmp r0,#-1
    addeq r2,#1
    beq 3b
    ldr r0,iAdrszmessresHome
    bl affichageMess
    add r0,r4,#LGVARRECH
    bl affichageMess 
    ldr r0,iAdrszCarriageReturn
    bl affichageMess 
    
4: 
    ldr r2,[fp]                 @ search variable PATH
    add r2,r2,#2
    ldr r1,iAdrszVarRech2
5:
    ldr r0,[fp,r2,lsl #2]
    cmp r0,#0
    beq 6f
    mov r4,r0
    bl searchSubBeginString
    cmp r0,#-1
    addeq r2,#1
    beq 5b
    ldr r0,iAdrszmessresPath
    bl affichageMess
    add r0,r4,#LGVARRECH
    bl affichageMess            @ affichage message dans console 
    ldr r0,iAdrszCarriageReturn
    bl affichageMess 
    
6: 
    ldr r0,iAdrszMessFinOK
    bl affichageMess
100:                                    @ standard end of the program
    mov r0, #0                          @ return code
    mov r7, #EXIT                       @ request to exit program
    swi 0                               @ perform the system call

iAdrszMessDebutPgm:       .int szMessDebutPgm
iAdrszMessFinOK:          .int szMessFinOK
iAdrszCarriageReturn:     .int szCarriageReturn
iAdrszVarRech:            .int szVarRech
iAdrszVarRech1:           .int szVarRech1
iAdrszVarRech2:           .int szVarRech2
iAdrszmessresUser:        .int szmessresUser
iAdrszmessresPath:        .int szmessresPath
iAdrszmessresHome:        .int szmessresHome
/******************************************************************/
/*   search a substring at the string  beguining                          */ 
/******************************************************************/
/* r0 contains the address of the input string */
/* r1 contains the address of substring */
/* r0 returns index of substring in string or -1 if not found */
searchSubBeginString:
    push {r1-r5,lr}                       @ save registers 
    mov r2,#0                             @ counter byte input string
    mov r3,#0                             @ counter byte string 
1:
    ldrb r4,[r1,r3]
    ldrb r5,[r0,r2]                       @ load byte string 
    cmp r5,#0
    beq 3f
    cmp r4,#0                             @ zero final ?
    moveq r0,#0                           @ yes string find in position 0
    beq 100f
    cmp r5,r4                             @ compare character 
    beq 2f
    mov r0,#-1                            @ no return  no find
    b 100f
2:
    add r2,r2,#1                          @ and increment counter byte
    add r3,r3,#1                          @ and increment 
    b 1b                                  @ and loop
3:                                        @ 
    cmp r4,#0
    movne r0,#-1                          @ yes returns no find
    bne 100f
    mov r0,#0                             @ string find in position 0
100:
    pop {r1-r5,lr}                        @ restaur registers
    bx lr   

/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
.include "../affichage.inc"

Output:

Program 32 bits start.
result for USER :u0_a252
result for HOME :/data/data/com.termux/files/home
result for PATH :/data/data/com.termux/files/usr/bin:/data/data/com.termux/files/home/scripts:/data/data/com.termux/files/usr/lib:.
Program normal end.

Arturo

print ["path:" env\PATH]
print ["user:" env\USER]
print ["home:" env\HOME]

Output:

path: /Users/drkameleon/.arturo/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
user: drkameleon 
home: /Users/drkameleon

AutoHotkey

EnvGet, OutputVar, Path
MsgBox, %OutputVar%

AutoIt

ConsoleWrite("# Environment:" & @CRLF)

Local $sEnvVar = EnvGet("LANG")
ConsoleWrite("LANG : " & $sEnvVar & @CRLF)

ShowEnv("SystemDrive")
ShowEnv("USERNAME")

Func ShowEnv($N)
    ConsoleWrite( StringFormat("%-12s : %s\n", $N, EnvGet($N)) )
EndFunc   ;==>ShowEnv

Output:

# Environment:
LANG : DE
SystemDrive  : C:
USERNAME     : HaJo

AWK

The ENVIRON array contains the values of the current environment:

$ awk 'BEGIN{print "HOME:"ENVIRON["HOME"],"USER:"ENVIRON["USER"]}'

Output:

HOME:/home/suchrich USER:SuchRich

Environment variables can also be assigned to awk variables before execution, with (-v) options:

$ awk -v h=$HOME -v u=$USER 'BEGIN{print "HOME:"h,"USER:"u}'

Output:

HOME:/home/suchrich USER:SuchRich

Listing all the environment variables:

# http://ideone.com/St5SHF
BEGIN { print "# Environment:"
        for (e in ENVIRON) { printf( "%10s = %s\n", e, ENVIRON[e] ) }
}
END   { print "# Done." }

Output:

# Environment:
   AWKPATH = .:/usr/share/awk
AWKLIBPATH = /usr/lib/i386-linux-gnu/gawk
      LANG = en_US.UTF-8
      PATH = /usr/local/bin:/usr/bin:/bin
      HOME = /home/guest
       PWD = /home/guest
     SHLVL = 0
    TMPDIR = /home/guest
# Done.

BASIC

x$ = ENVIRON$("path")
PRINT x$

BaCon

Case matters and needs to match

PRINT GETENVIRON$("PATH")

IS-BASIC

100 ASK BORDER VAR01
110 ASK DEFAULT CHANNEL VAR02
120 ASK EDITOR BUFFER VAR03
130 ASK EDITOR KEY VAR04
140 ASK EDITOR VIDEO VAR05
150 ASK FAST SAVE VAR06
160 ASK INTERRUPT KEY VAR07
170 ASK INTERRUPT NET VAR08
180 ASK INTERRUPT STOP VAR09
190 ASK KEY CLICK VAR10
200 ASK KEY DELAY VAR11
210 ASK KEY RATE VAR12
220 ASK NET CHANNEL VAR13
230 ASK NET MACHINE VAR14
240 ASK REM1 VAR15
250 ASK REM2 VAR16
260 ASK SERIAL BAUD VAR17
270 ASK SERIAL FORMAT VAR18
280 ASK STATUS VAR19
290 ASK SOUND BUFFER VAR20
300 ASK SPEAKER VAR21
310 ASK TAPE LEVEL VAR22
320 ASK TAPE SOUND VAR23
330 ASK TIMER VAR24
340 ASK VIDEO COLOR VAR25
350 ASK VIDEO MODE VAR26
360 ASK VIDEO X VAR27
370 ASK VIDEO Y VAR28

or

ASK machine-option-code var

SmallBASIC

print env("HOME")
print env("PATH")
print env("USER")

ZX Spectrum Basic

The ZX Spectrum does not use environmental variables in a traditional sense. However, it does provide a set of system variables held at a fixed memory address:

10 PRINT "The border colour is "; PEEK (23624): REM bordcr
20 PRINT "The ramtop address is "; PEEK (23730) + 256 * PEEK (23731): REM ramtop
30 POKE 23609,50: REM set keyboard pip to 50

Batch File

Batch files don't have any other kind of variables except environment variables. They can be accessed by enclosing the variable name in percent signs:

echo %Foo%

For interactive use one can use set to view all environment variables or all variables starting with a certain string:

set
set Foo

BBC BASIC

Works with: BBC BASIC for Windows

      PRINT FNenvironment("PATH")
      PRINT FNenvironment("USERNAME")
      END
      
      DEF FNenvironment(envar$)
      LOCAL buffer%, size%
      SYS "GetEnvironmentVariable", envar$, 0, 0 TO size%
      DIM buffer% LOCAL size%
      SYS "GetEnvironmentVariable", envar$, buffer%, size%+1
      = $$buffer%

C

#include <stdlib.h>
#include <stdio.h>
 
int main() {
  puts(getenv("HOME"));
  puts(getenv("PATH"));
  puts(getenv("USER"));
  return 0;
}

C#

using System;

namespace RosettaCode {
    class Program {
        static void Main() {
            string temp = Environment.GetEnvironmentVariable("TEMP");
            Console.WriteLine("TEMP is " + temp);
        }
    }
}

C++

#include <cstdlib>
#include <cstdio>

int main()
{
   puts(getenv("HOME"));
   return 0;
}

Clojure

(System/getenv "HOME")

COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. Environment-Vars.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01  home PIC X(75).

       PROCEDURE DIVISION.
*          *> Method 1.      
           ACCEPT home FROM ENVIRONMENT "HOME"
           DISPLAY home

*          *> Method 2.
           DISPLAY "HOME" UPON ENVIRONMENT-NAME
           ACCEPT home FROM ENVIRONMENT-VALUE

           GOBACK
           .

CoffeeScript

Works with: node.js

for var_name in ['PATH', 'HOME', 'LANG', 'USER']
  console.log var_name, process.env[var_name]

Common Lisp

Access to environment variables isn't a part of the Common Lisp standard, but most implementations provide some way to do it.

Works with: LispWorks

(lispworks:environment-variable "USER")

Works with: SBCL

(sb-ext:posix-getenv "USER")

Works with: Clozure CL

(ccl:getenv "USER")

Works with: CLISP

(getenv "HOME")

Ways to do this in some other implementations are listed in the Common Lisp Cookbook.

D

Library: phobos

import std.stdio, std.process;

void main() {
    auto home = getenv("HOME");
}

Library: tango

import tango.sys.Environment;

void main() {
    auto home = Environment("HOME");
}

Delphi /Pascal

program EnvironmentVariable;

{$APPTYPE CONSOLE}

uses SysUtils;

begin
  WriteLn('Temp = ' + GetEnvironmentVariable('TEMP'));
end.

DuckDB

SELECT getenv('HOME'), getenv('USER');
┌────────────────┬────────────────┐
│ getenv('HOME') │ getenv('USER') │
│    varchar     │    varchar     │
├────────────────┼────────────────┤
│ /Users/peter   │ peter          │
└────────────────┴────────────────┘

E

Works with: E-on-Java

<unsafe:java.lang.System>.getenv("HOME")

Eiffel

The feature get returns the value of an environment variable. get is defined in the library class EXECUTION_ENVIRONMENT. So the class APPLICATION inherits from EXECUTION_ENVIRONMENT in order to make get available.

class
    APPLICATION
inherit
    EXECUTION_ENVIRONMENT
create
    make
feature {NONE} -- Initialization
    make
            -- Retrieve and print value for environment variable `USERNAME'.
        do
            print (get ("USERNAME"))
        end
end

Elixir

System.get_env("PATH")

Emacs Lisp

(getenv "HOME")

EMal

fun showVariable = <text variable|writeLine(variable + ": '"  + Runtime.get(variable) + "'")
showVariable("SystemDrive")
showVariable("USERNAME")
# we can get the environment variables as a map
Map variables = Runtime.variables()
writeLine(variables["TEMP"])

Output:

SystemDrive: 'C:'
USERNAME: 'XXXYYY'
C:\Users\xxxyyy\AppData\Local\Temp

Erlang

os:getenv( "HOME" ).

Euphoria

puts(1,getenv("PATH"))

F#

open System

[<EntryPoint>]
let main args =
    printfn "%A" (Environment.GetEnvironmentVariable("PATH"))
    0

Factor

"HOME" os-env print

Forth

Works with: GNU Forth

s" HOME" getenv type

Fortran

Works with: any Fortran compiler

program show_home
implicit none
character(len=32) :: home_val  ! The string value of the variable HOME
integer           :: home_len  ! The actual length of the value
integer           :: stat      ! The status of the value:
                               !  0 = ok
                               !  1 = variable does not exist
                               ! -1 = variable is not long enought to hold the result
call get_environment_variable('HOME', home_val, home_len, stat)
if (stat == 0) then
    write(*,'(a)') 'HOME = '//trim(home_val)
else
    write(*,'(a)') 'No HOME to go to!'
end if
end program show_home

FreeBASIC

' FB 1.05.0 Win64

Var v = Environ("SystemRoot")
Print v
Sleep

Output:

C:\WINDOWS

Frink

callJava["java.lang.System", "getenv", ["HOME"]]

Output:

/home/frink

FunL

println( System.getenv('PATH') )
println( $home )
println( $user )

FutureBasic

include "NSLog.incl"

NSLog(@"%@",fn NSUserName)
NSLog(@"%@",fn NSFullUserName)
NSLog(@"%@",fn NSHomeDirectory)
NSLog(@"%@",fn NSTemporaryDirectory)

HandleEvents

Go

Simply

package main

import (
    "fmt"
    "os"
)

func main() {
    fmt.Println(os.Getenv("SHELL"))
}

Output:

/bin/bash

Alternatively

Library function os.Environ returns all environment variables. You're on your own then to parse out the one you want. Example:

package main

import (
    "fmt"
    "os"
    "strings"
)

func main() {
    s := "SHELL"
    se := s + "="
    for _, v := range os.Environ() {
        if strings.HasPrefix(v, se) {
            fmt.Println(s, "has value", v[len(se):])
            return
        }
    }
    fmt.Println(s, "not found")
}

Output:

SHELL has value /bin/bash

Gri

Command get env fetches an environment variable into a synonym (a string)

get env \foo HOME
show "\foo"

Quotes can be used in the usual way if the environment variable name contains spaces (which is unusual, but possible).

get env \foo "X Y Z"

Groovy

System.getenv().each { property, value -> println "$property = $value"}

Haskell

import System.Environment
main = do getEnv "HOME" >>= print  -- get env var
          getEnvironment >>= print -- get the entire environment as a list of (key, value) pairs

hexiscript

println env "HOME"
println env "PATH"
println env "USER"

HicEst

CHARACTER string*255

string = "PATH="
SYSTEM(GEteNV = string)

i

software {
	print(load("$HOME"))
	print(load("$USER"))
	print(load("$PATH"))
}

Icon and Unicon

Works with: Unicon

procedure main(arglist)

if *envars = 0 then envars := ["HOME", "TRACE", "BLKSIZE","STRSIZE","COEXPSIZE","MSTKSIZE", "IPATH","LPATH","NOERRBUF"] 

every v := !sort(envars) do 
   write(v," = ",image(getenv(v))|"* not set *")
end

J

2!:5'HOME'

Java

System.getenv("HOME") // get env var
System.getenv()       // get the entire environment as a Map of keys to values

JavaScript

The JavaScript language has no facilities to access the computer: it relies on the host environment to provide it.

Works with: JScript

var shell = new ActiveXObject("WScript.Shell");
var env = shell.Environment("PROCESS");
WScript.echo('SYSTEMROOT=' + env.item('SYSTEMROOT'));

Joy

"HOME" getenv.

jq

env.HOME

If the environment variable name has spaces or special characters, the name must be given as a string, e.g. env."HOME".

jsish

The Jsi Util module provides access to set Util.setenv(name, value) and get Util.getenv(name) process environment variables. Util.getenv(), with no argument will return an object with all available name:value pairs.

/* Environment variables, in Jsi */
puts(Util.getenv("HOME"));
var environment = Util.getenv();
puts(environment.PATH);

Julia

Works with: Julia version 0.6

@show ENV["PATH"]
@show ENV["HOME"]
@show ENV["USER"]

K

_getenv "HOME"

Kotlin

// version 1.0.6

// tested on Windows 10

fun main(args: Array<String>) {
   println(System.getenv("SystemRoot"))
}

Output:

C:\WINDOWS

langur

writeln "HOME: ", _env'HOME
writeln "PATH: ", _env'PATH
writeln "USER: ", _env'USER

Lasso

#!/usr/bin/lasso9

define getenv(sysvar::string) => {
	local(regexp = regexp(
		-find = `(?m)^` + #sysvar + `=(.*?)$`,
		-input = sys_environ -> join('\n'),
		-ignorecase
	))
	return #regexp ->find ? #regexp -> matchString(1)
}

stdoutnl(getenv('HOME'))
stdoutnl(getenv('PATH'))
stdoutnl(getenv('USER'))
stdoutnl(getenv('WHAT'))

Output:

/Users/rosetta
/opt/local/bin:/opt/local/sbin:/usr/local/bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/X11/bin
rosetta

Liberty BASIC

Built-in variables

print StartupDir$
print DefaultDir$

Other variables

print GetEnvironmentVariable$("USERNAME")
    print GetEnvironmentVariable$("USERPROFILE") ' equivalent to UNIX HOME variable
    print GetEnvironmentVariable$("PATH")
    end

function GetEnvironmentVariable$(lpName$)
    'get the value of an environment variable
    nSize = 1024

[Retry]
    lpBuffer$ = space$(nSize)

    calldll #kernel32, "GetEnvironmentVariableA", _
        lpName$   as ptr, _
        lpBuffer$ as ptr, _
        nSize     as ulong, _
        result    as ulong

    select case
        ' buffer too small
        case result > nSize
        nSize = result
        goto [Retry]

        ' variable found
        case result > 0
        GetEnvironmentVariable$ = left$(lpBuffer$, result)
    end select
end function

LIL

LIL does not ship with a command to retrieve process environment variables. The system command could be used, but here is an extension in C for the lil shell.

static LILCALLBACK lil_value_t fnc_env(lil_t lil, size_t argc, lil_value_t* argv)
{
    if (!argc) return NULL;
    return lil_alloc_string(getenv(lil_to_string(argv[0])));
}

Then inside the main functions for repl and nonint (Interactive, Noninteractive):

lil_register(lil, "env", fnc_env);

Now lil can get at the environment. That could fairly easily be extended further to return the entire environment array if no arguments are passed to env, this just returns an empty result for that case. Defaults values could also be supported if the named environment variable is empty. Etcetera. Setting variables would be similar, a few lines of lil C to wrap a call to libc setenv in a new command, and registering the command.

Output:

prompt$ make
cc -c -g3 -std=c99 -pedantic -Wall -Wextra -Wno-format -Wno-long-long -Wno-unused-parameter  main.c -o main.o
cc -g -L.  -o lil main.o -llil -lm

prompt$ lil
Little Interpreted Language Interactive Shell
# env TERM
xterm-256color

Lingo

Library: Shell Xtra

sx = xtra("Shell").new()
if the platform contains "win" then
  path = sx.shell_cmd("echo %PATH%").line[1]
else
  path = sx.shell_cmd("echo $PATH").line[1]
end if

Logtalk

Using the standard library:

os::environment_variable('PATH', Path).

LSL

Rez a box on the ground, and add the following as a New Script.

default {
	state_entry() {
		llOwnerSay("llGetTimestamp()="+(string)llGetTimestamp());
		llOwnerSay("llGetEnergy()="+(string)llGetEnergy());
		llOwnerSay("llGetFreeMemory()="+(string)llGetFreeMemory());
		llOwnerSay("llGetMemoryLimit()="+(string)llGetMemoryLimit());
	}
}

Output:

llGetTimestamp()=2012-07-18T01:26:12.133137Z
llGetEnergy()=1.230000
llGetFreeMemory()=16000
llGetMemoryLimit()=65536

Lua

print( os.getenv( "PATH" ) )

M2000 Interpreter

Module CheckIt {
      \\ using read only variablles
      Print "Platform: ";Platform$
      Print "Computer Os: "; Os$
      Print "Type of OS: ";OsBit;" bit"
      Print "Computer Name:";  Computer$
      Print "User Name: "; User.Name$
      \\ using WScript.Shell
      Declare objShell "WScript.Shell"
      With  objShell, "Environment" set env ("Process")
      With env, "item" as Env$()
      Print Env$("PATH")
      Print Env$("HOMEPATH")
      Declare objShell Nothing
      \\ using internal Information object
      Declare OsInfo INFORMATION
      With OsInfo, "build" as build, "NtDllVersion" as NtDllVersion$
      Method OsInfo, "GetCurrentProcessSID" as PID$
      Method OsInfo, "IsProcessElevated" as isElevated
      Print "Os build number: ";build
      Print "Nr Dll version: ";NtDllVersion$
      Print "ProcessSID: ";pid$
      Print "Is Process Eleveted: ";isElevated
      Declare OsInfo Nothing
}
Checkit

Make

Make variables are initialized from the environment, so simply

TARGET = $(HOME)/some/thing.txt
foo:
	echo $(TARGET)

The shell code in a rule can use the shell's environment in the usual way (Unix Shell), but remember $ must be doubled $$ to get a literal $ in that code.

bar:
        echo "$$HOME"

If you mistakenly write just $HOME then it means the makefile $H followed by characters OME.

H = oops ...
bar:
	echo $HOME

# prints oops ... OME

Maple

getenv("PATH");

Mathematica / Wolfram Language

Environment["PATH"]

MATLAB / Octave

    getenv('HOME')
    getenv('PATH')
    getenv('USER')

Mercury

:- module env_var.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module maybe, string.

main(!IO) :-
    io.get_environment_var("HOME", MaybeValue, !IO),
    (
        MaybeValue = yes(Value),
        io.write_string("HOME is " ++ Value ++ "\n", !IO)
    ;
        MaybeValue = no,
        io.write_string("environment variable HOME not set\n", !IO)
    ).

min

Works with: min version 0.19.3

$PATH

Modula-3

MODULE EnvVars EXPORTS Main;

IMPORT IO, Env;

VAR
  k, v: TEXT;

BEGIN
  IO.Put(Env.Get("HOME") & "\n");

  FOR i := 0 TO Env.Count - 1 DO
    Env.GetNth(i, k, v);
    IO.Put(k & " = " & v & "\n")
  END
END EnvVars.

MUMPS

ANSI MUMPS doesn't allow access to the operating system except possibly through the View command and $View function, both of which are implementation specific. Intersystems' Caché does allow you to create processes with the $ZF function, and if the permissions for the Caché process allow it you can perform operating system commands.

In Caché on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:

 Set X=$ZF(-1,"show logical")
 Set X=$ZF(-1,"show symbol")

NetRexx

When NetRexx runs under a JVM, system ENVIRONMENT variables are complimented by JVM system properties. This sample shows how to get both.

/* NetRexx */
options replace format comments java crossref symbols nobinary

runSample(arg)
return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method sysEnvironment(vn = '') public static
  if vn.length > 0 then do
    envName = vn
    envValu = System.getenv(envName)
    if envValu = null then envValu = ''
    say envName '=' envValu
    end
  else do
    envVars = System.getenv()
    key = String
    loop key over envVars.keySet()
      envName = key
      envValu = String envVars.get(key)
      say envName '=' envValu
      end key
    end
  return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method sysProperties(vn = '') public static
  if vn.length > 0 then do
    propName = vn
    propValu = System.getProperty(propName)
    if propValu = null then propValu = ''
    say propName '=' propValu
    end
  else do
    sysProps = System.getProperties()
    key = String
    loop key over sysProps.keySet()
      propName = key
      propValu = sysProps.getProperty(key)
      say propName '=' propValu
      end key
    end
  return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) public static
  parse arg ev pv .
  if ev = '' then ev = 'CLASSPATH'
  if pv = '' then pv = 'java.class.path'
  say '-'.left(80, '-').overlay(' Environment "'ev'" ', 5)
  sysEnvironment(ev)
  say '-'.left(80, '-').overlay(' Properties "'pv'" ', 5)
  sysProperties(pv)
  say
  say '-'.left(80, '-').overlay(' Environment ', 5)
  sysEnvironment()
  say '-'.left(80, '-').overlay(' Properties ', 5)
  sysProperties()
  say
  return

Output:

---- Environment "CLASSPATH" ---------------------------------------------------
CLASSPATH = /usr/local/NetRexx/runlib/NetRexxR.jar:.
---- Properties "java.class.path" ----------------------------------------------
java.class.path = /usr/local/NetRexx/runlib/NetRexxR.jar:.

---- Environment ---------------------------------------------------------------
HOME = /Users/nrxuser
HISTCONTROL = ignoredups
USER = nrxuser
ZBASHRC = 1
COMMAND_MODE = unix2003
CLASSPATH = /usr/local/NetRexx/runlib/NetRexxR.jar:.
SHELL = /bin/bash
. . .
---- Properties ----------------------------------------------------------------
java.vm.specification.name = Java Virtual Machine Specification
sun.cpu.endian = little
sun.io.unicode.encoding = UnicodeBig
sun.os.patch.level = unknown
file.separator = /
java.vendor = Oracle Corporation
sun.java.launcher = SUN_STANDARD
java.specification.vendor = Oracle Corporation
user.home = /Users/nrxuser
java.class.path = /usr/local/NetRexx/runlib/NetRexxR.jar:.
java.vm.vendor = Oracle Corporation
java.runtime.name = Java(TM) SE Runtime Environment
. . .

NewLISP

> (env "SHELL")
"/bin/zsh"
> (env "TERM")
"xterm"

Nim

import os
echo getEnv("HOME")

NSIS

While common environment variables exist as constants within the NSIS script compilation environment (see NSIS documentation), arbitrarily-named environment variables' values may be retrieved using ExpandEnvStrings.

ExpandEnvStrings $0 "%PATH%" ; Retrieve PATH and place it in builtin register 0.
ExpandEnvStrings $1 "%USERPROFILE%" ; Retrieve the user's profile location and place it in builtin register 1.
ExpandEnvStrings $2 "%USERNAME%" ; Retrieve the user's account name and place it in builtin register 2.

Nu

$env.HOME

Objective-C

[[NSProcessInfo processInfo] environment] returns an NSDictionary of the current environment.

[[[NSProcessInfo processInfo] environment] objectForKey:@"HOME"]

OCaml

Sys.getenv "HOME"

Oforth

System getEnv("PATH") println

Oz

{System.showInfo "This is where Mozart is installed: "#{OS.getEnv 'OZHOME'}}

PARI/GP

Works with: PARI/GP version 2.6.0 and above

getenv("HOME")

Works with: PARI/GP version 2.4.3 and above

externstr("echo $HOME")

Works with: PARI/GP version 2.0.3 and above

In older versions, the command must effectively be triple-quoted:

extern("echo \"\\\"$HOME\\\"\"")

The shell sees

echo "\"$HOME\""

which causes it to return

"/home/username"

so that the result is interpreted by GP as a string.

Leaving out the quotation marks allows external commands to return expressions that are then evaluated by GP. For example,

extern("echo Pi")

causes the shell to send Pi back to GP, which interprets the result and returns

%1 = 3.141592653589793238462643383

PascalABC.NET

##
system.Environment.GetEnvironmentVariable('TEMP').Println;

Perl

The %ENV hash maps environment variables to their values:

print $ENV{HOME}, "\n";

The POSIXmodule also has getenv() which is the same thing as a function.

use POSIX 'getenv';
print getenv("HOME"),"\n";

Phix

without js -- none such in a browser, that I know of
?getenv("PATH")

Phixmonti

/# Rosetta Code problem: http://rosettacode.org/wiki/Environment_variables
by Galileo, 10/2022 #/

def getenv
	" > output.txt" chain cmd if "Error!" else "output.txt" "r" fopen dup fgets swap fclose endif
enddef

"path" getenv print

PHP

The $_ENV associative array maps environmental variable names to their values:

$_ENV['HOME']

PicoLisp

: (sys "TERM")
-> "xterm"

: (sys "SHELL")
-> "/bin/bash"

Pike

write("%s\n", getenv("SHELL"));

Output:

/bin/bash

PowerShell

Environment variables can be found in the Env: drive and are accessed using a special variable syntax:

$Env:Path

To get a complete listing of all environment variables one can simply query the appropriate drive for its contents:

Get-ChildItem Env:

Prolog

SWI-Prolog has the built in function getenv.

 ?- getenv('TEMP', Temp).

PureBasic

PureBasic has the built in funtion

GetEnvironmentVariable("Name")

Example

If OpenConsole()
  PrintN("Path:"+#CRLF$ + GetEnvironmentVariable("PATH"))
  PrintN(#CRLF$+#CRLF$+"NUMBER_OF_PROCESSORS= "+ GetEnvironmentVariable("NUMBER_OF_PROCESSORS"))

  PrintN(#CRLF$+#CRLF$+"Press Enter to quit.")
  Input() 
  CloseConsole()
EndIf

Python

The os.environ dictionary maps environmental variable names to their values:

import os
os.environ['HOME']

R

Sys.getenv("PATH")

Racket

#lang racket
(getenv "HOME")

Raku

(formerly Perl 6)

Works with: Rakudo version #24 "Seoul"

The %*ENV hash maps environment variables to their values:

say %*ENV<HOME>;

REBOL

print get-env "HOME"

Retro

here "HOME" getEnv
here puts

REXX

Each REXX interpreter sets its own rules by what identifies the pool in which the environmental variables are named. In addition, each operation system (OS) has their own definition as well. This makes it problematic in the accessing/acquiring of environmental variables. Most programmers know what REXX interpreter they are using, and furthermore, they also know what operating system they are writing the REXX program for, so most programmers hard-wire (explicitly code) the "access-name" of the system environmental variables into the program.

The following will work for

• Regina
• R4
• ROO

for the DOS shell under Microsoft Windows (any version).
(Also successfully tested with Regina under the bash shell in UNIX.)

Works with: Regina

Works with: R4

Works with: ROO

/*REXX program shows how to get an environmental variable under Windows*/

x=value('TEMP',,'SYSTEM')

The following will work for

• PC/REXX
• Personal REXX
• Regina
• Open Object Rexx

for the DOS shell under Microsoft Windows (any version).
(Also successfully tested with Regina and ooRexx under the bash shell in UNIX.)

Works with: PC/REXX

Works with: Personal REXX

Works with: Regina

Works with: ooRexx

/*REXX program shows how to get an environmental variable under Windows*/

x=value('TEMP',,'ENVIRONMENT')

The brexx interpreter provides a getenv function for accessing environment variables:

Works with: Brexx

x=getenv("PATH") /* Get the contents of the path environment variable */

Other REXX interpreters have their own requirements to identify the SYSTEM environment.
VM/CMS has something called GLOBALV (global variables) and are of three types:

• temporary,   lasting only for execution of the REXX program
• temporary,   lasting only for LOGON or CMS session)
• permanent

As such, CMS has its own command interface for these variables.

Ring

see get("path")

Ruby

The ENV hash maps environment variable names to their values:

ENV['HOME']

Run BASIC

' ------- Major environment variables -------------------------------------------
'DefaultDir$    - The folder path where program files are read/written by default
'Platform$      - The operating system on which Run BASIC is being hosted
'UserInfo$      - This is information about the user's web browser
'UrlKeys$       - Contains informational parameters from the URL submitted when the user connected
'UserAddress$   - Contains the IP address of the user
'ProjectsRoot$  - The folder path where Run BASIC keeps programming projects
'ResourcesRoot$ - The folder path where Run BASIC keeps web-servable files
'Err$           - A description of the last runtime error
'Err            - A numeric code for the last runtime error (errors that have no code use zero)
'EventKey$      - The id of the object that generated the last user event
'RowIndex       - The numeric index of the table or database accessor link that generated the last user event


print "User Info is   : ";UserInfo$
print "Platform is    : ";Platform$
print "Url Keys is    : ";UrlKeys$
print "User Address is: ";UserAddress$
print "Event Key is   : ";EventKey$
print "Default Dir is : ";DefaultDir$

{{out}}
User Info is   : Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.79 Safari/535.11
Platform is    : win32
Url Keys is    : none
User Address is: 127.0.0.1
Event Key is   : none
Default Dir is : c:\rbp101

Rust

use std::env;

fn main() {
    println!("{:?}", env::var("HOME"));
    println!();
    for (k, v) in env::vars().filter(|(k, _)| k.starts_with('P')) {
        println!("{}: {}", k, v);
    }
}

Output:

Ok("/root")

PATH: /root/.cargo/bin:/root/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PLAYGROUND_EDITION: 2018
PLAYGROUND_TIMEOUT: 10
PWD: /playground

Note that var_os and vars_os are also available, which produce OsString instead of String, offering compatibility with non-utf8 systems.

Scala

sys.env.get("HOME")

Seed7

Seed7 provides the function getenv, to get the value of an environment variable. Environment variables are highly operating system dependent. Some variables such as HOME are not always defined and others like PATH use an operating system dependent format (different delimiters). Seed7 provides the functions homeDir and getSearchPath to get the home directory and the search path in an operating system independent manner.

$ include "seed7_05.s7i";
 
const proc: main is func
  begin
    writeln(getenv("HOME"));
  end func;

Sidef

The ENV hash maps environment variables to their values:

say ENV{'HOME'};

Slate

Environment variables at: 'PATH'.
"==> '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games'"

Slope

(env "HOME")

Smalltalk

Use the OSProcess library to gain access to environment variables:

OSProcess thisOSProcess environment at: #HOME.
OSProcess thisOSProcess environment at: #PATH.
OSProcess thisOSProcess environment at: #USER.

SNOBOL4

Works with: Macro Spitbol

Works with: CSnobol

The host(4) function returns a known environment variable.

         output = host(4,'PATH')
end

Standard ML

OS.Process.getEnv "HOME"

returns an option type which is either SOME value or NONE if variable doesn't exist

Stata

Use the env extended macro function.

display "`:env PATH'"
display "`:env USERNAME'"
display "`:env USERPROFILE'"

Swift

print("USER: \(ProcessInfo.processInfo.environment["USER"] ?? "Not set")")
print("PATH: \(ProcessInfo.processInfo.environment["PATH"] ?? "Not set")")

True BASIC

ASK #1: ACCESS type$
ASK BACK red
ASK COLOR red
ASK COLOR MIX (2) red, green, blue
ASK CURSOR vble1, vble2
ASK #2: DATUM type$
ASK DIRECTORY dir$
ASK #3: ERASABLE type$
ASK #4: FILESIZE vble09
ASK #5: FILETYPE vble10
ASK FREE MEMORY vble11
ASK #61: MARGIN vble12
ASK MAX COLOR vble13
ASK MAX CURSOR vble1, vble2
ASK MODE vble15$
ASK NAME vble16$
ASK #7: ORGANIZATION vble17$
ASK PIXELS vble1, vble2
ASK #8: POINTER vble19$
ASK #9: RECORD vble20
ASK #1: RECSIZE vble21
ASK #2: RECTYPE vble22$
ASK SCREEN vble1, vble2, vble3, vble4
ASK #3: SETTER vble24$
ASK TEXT JUSTIFY vble1$, vble2$
ASK WINDOW vble1, vble2, vble3, vble4
ASK #4: ZONEWIDTH vble27

Tcl

The env global array maps environmental variable names to their values:

$env(HOME)

TXR

TXR can treat the environment vector as text stream:

@(next :env)
@(collect)
@VAR=@VAL
@(end)

A recently added gather directive is useful for extracting multiple items of data from an unordered stream of this kind (not only the environment vector):

@(next :env)
@(gather)
HOME=@home
USER=@user
PATH=@path
@(end)

What if some of the variables might not exist? Gather has some discipline for that. The following means that three variables are required (the gather construct fails if they are not found), but shell is optional with a default value of /bin/sh if it is not extracted from the data:

@(next :env)
@(gather :vars (home user path (shell "/bin/sh")))
HOME=@home
USER=@user
PATH=@path
SHELL=@shell
@(end)

From TXR Lisp, the environment is available via the (env) function, which returns a raw list of "name=value strings. The (env-hash) function returns a hash from environment keys to their values.

$ ./txr -p "(mapcar (env-hash) '(\"HOME\" \"USER\" \"PATH\"))"
("/home/kaz" "kaz" "/home/kaz/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/kaz/bin"

Here, the hash is being used as a function to filter several environment keys to their values via mapcar.

Platform note: On POSIX, environment variables, which are extracted using extern char **environ are assumed to contain UTF-8. On Windows, the GetEnvironmentStringsW function is used to obtain the environment vector as wide character data.

UNIX Shell

In the Unix Shell Language, environment variables are available as ordinary variables:

echo "$HOME"

An ordinary variable can be marked as an environment variable with the export command:

export VAR

Now child processes launched by the shell will have an environment variable called VAR.

The Unix command "env" will print out all of the environment variables as key=value pairs on standard output.

Ursa

import "system"
out (system.getenv "HOME") endl console

Ursala

The argument to the main program is a record initialized by the run-time system in which one of the fields (environs) contains the environment as a list of key:value pairs.

#import std

#executable ('parameterized','')

showenv = <.file$[contents: --<''>]>+ %smP+ ~&n-={'TERM','SHELL','X11BROWSER'}*~+ ~environs

The rest of this application searches for the three variables named and displays them on standard output.

Here is a bash session:

$ showenv
<
   'TERM': 'Eterm',
   'SHELL': '/bin/bash',
   'X11BROWSER': '/usr/bin/firefox'>

V (Vlang)

// Environment variables in V
// v run environment_variables.v
module main

import os

pub fn main() {
    print('In the $os.environ().len environment variables, ')
    println('\$HOME is set to ${os.getenv('HOME')}')
}

Output:

prompt$ v run environment-variables.v
In the 64 environment variables, $HOME is set to /home/btiffin

Vedit macro language

Get_Environment(10,"PATH")
Message(@10)

Or with short keywords:

GE(10,"PATH") M(@10)

Visual Basic

Works with: Visual Basic version VB6 Standard

Debug.Print Environ$("PATH")

Wren

Wren CLI doesn't currently expose a way to obtain the value of an environment variable.

However, if Wren is embedded in (say) a suitable Go program, then we can ask the latter to obtain it for us.

/* Environment_variables.wren */
class Environ {
    foreign static variable(name)
}

System.print(Environ.variable("SHELL"))

which we embed in the following Go program and run it.

Library: WrenGo

/* Environment_variables.go */
package main

import (
    wren "github.com/crazyinfin8/WrenGo"
    "os"
)

type any = interface{}

func getEnvironVariable(vm *wren.VM, parameters []any) (any, error) {
    name := parameters[1].(string)
    return os.Getenv(name), nil
}

func main() {
    vm := wren.NewVM()
    fileName := "Environment_variables.wren"
    methodMap := wren.MethodMap{"static variable(_)": getEnvironVariable}
    classMap := wren.ClassMap{"Environ": wren.NewClass(nil, nil, methodMap)}
    module := wren.NewModule(classMap)
    vm.SetModule(fileName, module)
    vm.InterpretFile(fileName)
    vm.Free()
}

Output:

/bin/bash

XPL0

This task was particularly worthwhile because it revealed a discrepancy in the way 32-bit XPL0 accessed the environment block. A small mod to Tran's PMODE.ASM DPMI was required to make the 32-bit protected-mode version work the same as the 16-bit real-mode versions.

include c:\cxpl\codes;          \intrinsic 'code' declarations
string 0;                       \use zero-terminated strings
int  CpuReg, PspSeg, EnvSeg, I, J, C;
char EnvVar;
[CpuReg:= GetReg;               \access CPU registers
PspSeg:= CpuReg(9);             \get segment address of our PSP
EnvSeg:= Peek(PspSeg,$2C) + Peek(PspSeg,$2D)<<8;
EnvVar:= "PATH";                \environment variable
I:= 0;
loop    [J:= 0;
        loop    [C:= Peek(EnvSeg,I);  I:= I+1;
                if C = 0 then quit;
                if C = EnvVar(J) then
                        [J:= J+1;
                        if J = 4 then
                                [Text(0, EnvVar);               \show env. var.
                                loop    [C:= Peek(EnvSeg,I);    \ and rest of
                                        I:= I+1;                \ its string
                                        if C = 0 then exit;
                                        ChOut(0, C);
                                        ];
                                ];
                        ]
                else J:= 5;     \line must start with environment variable
                ];
        if Peek(EnvSeg,I) = 0 then quit;        \double 0 = env. var. not found
        ];
]

Output:

PATH=\masm6;C:\;C:\CXPL;C:\UTIL;C:\DOS;C:\BORLANDC\BIN

Yabasic

peek$("env","NAME") Return the environment variable specified by NAME (which may be any string expression).

Which kind of environment variables are available on your system depends, as well as their meaning, on your system; however typing env on the command line will produce a list (for Windows and Unix alike).

Note, that peek$("env",...) can be written as peek$("environment",...) too.

zkl

System.getenv("HOME")
/home/craigd
System.getenv() //--> Dictionary of all env vars