Show how to get one of your process'senvironment variables.
The available variables vary by system; some of the common ones available on Unix include:
print(os:getenv(‘HOME’))
/* 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 */ /***********************/.dataszMessDebutPgm: .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 finalszVarRech1: .asciz "HOME=" .equ LGVARRECH1, . - szVarRech1 - 1 // car zero finalszVarRech2: .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,qAdrszVarRech1: 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,qAdrszVarRech13: 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,qAdrszVarRech25: 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 affichageMess100: // standard end of the program mov x0, #0 // return code mov x8,EXIT svc 0 // perform the system callqAdrszMessDebutPgm: .quad szMessDebutPgmqAdrszMessFinOK: .quad szMessFinOKqAdrszCarriageReturn: .quad szCarriageReturnqAdrszVarRech: .quad szVarRechqAdrszVarRech1: .quad szVarRech1qAdrszVarRech2: .quad szVarRech2qAdrszmessresUser: .quad szmessresUserqAdrszmessresPath: .quad szmessresPathqAdrszmessresHome: .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 100f2: add x2,x2,#1 // and increment counter byte add x3,x3,#1 // and increment b 1b // and loop3: mov x2,-1 // cmp x4,#0 mov x0,#-1 // yes returns no find bne 100f mov x0,#0 // string find in position 0100: 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"
Program 64 bits start.result for USER :u0_a420result for HOME :/data/data/com.termux/files/homeresult 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.
Print a single environment variable.
withAda.Environment_Variables;useAda.Environment_Variables;withAda.Text_Io;useAda.Text_Io;procedurePrint_PathisbeginPut_Line("Path : "&Value("PATH"));endPrint_Path;
Print all environment variable names and values.
withAda.Environment_Variables;useAda.Environment_Variables;withAda.Text_Io;useAda.Text_Io;procedureEnv_VarsisprocedurePrint_Vars(Name,Value:inString)isbeginPut_Line(Name&" : "&Value);endPrint_Vars;beginIterate(Print_Vars'access);endEnv_Vars;
UsesMatreshka.
withAda.Wide_Wide_Text_IO;withLeague.Application;withLeague.Strings;procedureMainisfunction"+"(Item:Wide_Wide_String)returnLeague.Strings.Universal_StringrenamesLeague.Strings.To_Universal_String;beginAda.Wide_Wide_Text_IO.Put_Line(League.Application.Environment.Value(+"HOME").To_Wide_Wide_String);endMain;
print((getenv("HOME"), new line))⎕ENV'HOME'HOME/home/russtopia
tellapplication"Finder"togetnameofhome
"HOME : "&(do shell script"echo $HOME"&", PATH : "&(do shell script"echo $PATH"&", USER : "&(do shell script"echo $USER")))
/* 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 */ /***********************/.dataszMessDebutPgm: .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 finalszVarRech1: .asciz "HOME=" .equ LGVARRECH1, . - szVarRech1 - 1 @ car zero finalszVarRech2: .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,iAdrszVarRech1: 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,iAdrszVarRech13: 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,iAdrszVarRech25: 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 affichageMess100: @ standard end of the program mov r0, #0 @ return code mov r7, #EXIT @ request to exit program swi 0 @ perform the system calliAdrszMessDebutPgm: .int szMessDebutPgmiAdrszMessFinOK: .int szMessFinOKiAdrszCarriageReturn: .int szCarriageReturniAdrszVarRech: .int szVarRechiAdrszVarRech1: .int szVarRech1iAdrszVarRech2: .int szVarRech2iAdrszmessresUser: .int szmessresUseriAdrszmessresPath: .int szmessresPathiAdrszmessresHome: .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 100f2: add r2,r2,#1 @ and increment counter byte add r3,r3,#1 @ and increment b 1b @ and loop3: @ cmp r4,#0 movne r0,#-1 @ yes returns no find bne 100f mov r0,#0 @ string find in position 0100: pop {r1-r5,lr} @ restaur registers bx lr /***************************************************//* ROUTINES INCLUDE *//***************************************************/.include "../affichage.inc"Program 32 bits start.result for USER :u0_a252result for HOME :/data/data/com.termux/files/homeresult 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.
print["path:"env\PATH]print["user:"env\USER]print["home:"env\HOME]
path: /Users/drkameleon/.arturo/bin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbinuser: drkameleon home: /Users/drkameleon
EnvGet,OutputVar,PathMsgBox,%OutputVar%
ConsoleWrite("# Environment:"&@CRLF)Local$sEnvVar=EnvGet("LANG")ConsoleWrite("LANG : "&$sEnvVar&@CRLF)ShowEnv("SystemDrive")ShowEnv("USERNAME")FuncShowEnv($N)ConsoleWrite(StringFormat("%-12s : %s\n",$N,EnvGet($N)))EndFunc;==>ShowEnv
# Environment:LANG : DESystemDrive : C:USERNAME : HaJo
The ENVIRON array contains the values of the current environment:
$awk'BEGIN{print "HOME:"ENVIRON["HOME"],"USER:"ENVIRON["USER"]}'
HOME:/home/suchrich USER:SuchRich
Environment variables can also be assigned to awk variables before execution, with (-v) options:
$awk-vh=$HOME-vu=$USER'BEGIN{print "HOME:"h,"USER:"u}'
HOME:/home/suchrich USER:SuchRich
Listing all the environment variables:
# http://ideone.com/St5SHFBEGIN{print"# Environment:"for(einENVIRON){printf("%10s = %s\n",e,ENVIRON[e])}}END{print"# Done."}
# Environment: AWKPATH = .:/usr/share/awkAWKLIBPATH = /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.
x$=ENVIRON$("path")PRINTx$
Case matters and needs to match
PRINTGETENVIRON$("PATH")
100 ASK BORDER VAR01110 ASK DEFAULT CHANNEL VAR02120 ASK EDITOR BUFFER VAR03130 ASK EDITOR KEY VAR04140 ASK EDITOR VIDEO VAR05150 ASK FAST SAVE VAR06160 ASK INTERRUPT KEY VAR07170 ASK INTERRUPT NET VAR08180 ASK INTERRUPT STOP VAR09190 ASK KEY CLICK VAR10200 ASK KEY DELAY VAR11210 ASK KEY RATE VAR12220 ASK NET CHANNEL VAR13230 ASK NET MACHINE VAR14240 ASK REM1 VAR15250 ASK REM2 VAR16260 ASK SERIAL BAUD VAR17270 ASK SERIAL FORMAT VAR18280 ASK STATUS VAR19290 ASK SOUND BUFFER VAR20300 ASK SPEAKER VAR21310 ASK TAPE LEVEL VAR22320 ASK TAPE SOUND VAR23330 ASK TIMER VAR24340 ASK VIDEO COLOR VAR25350 ASK VIDEO MODE VAR26360 ASK VIDEO X VAR27370 ASK VIDEO Y VAR28
or
ASK machine-option-code var
printenv("HOME")printenv("PATH")printenv("USER")
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:
10PRINT"The border colour is ";PEEK(23624):REMbordcr20PRINT"The ramtop address is ";PEEK(23730)+256*PEEK(23731):REMramtop30POKE23609,50:REMsetkeyboardpipto50
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 useset to view all environment variables or all variables starting with a certain string:
setsetFoo
PRINTFNenvironment("PATH")PRINTFNenvironment("USERNAME")ENDDEFFNenvironment(envar$)LOCALbuffer%,size%SYS"GetEnvironmentVariable",envar$,0,0TOsize%DIMbuffer%LOCALsize%SYS"GetEnvironmentVariable",envar$,buffer%,size%+1=$$buffer%
#include<stdlib.h>#include<stdio.h>intmain(){puts(getenv("HOME"));puts(getenv("PATH"));puts(getenv("USER"));return0;}
usingSystem;namespaceRosettaCode{classProgram{staticvoidMain(){stringtemp=Environment.GetEnvironmentVariable("TEMP");Console.WriteLine("TEMP is "+temp);}}}
#include<cstdlib>#include<cstdio>intmain(){puts(getenv("HOME"));return0;}
(System/getenv"HOME")
IDENTIFICATIONDIVISION.PROGRAM-ID.Environment-Vars.DATADIVISION.WORKING-STORAGESECTION.01homePIC X(75).PROCEDUREDIVISION.**> Method 1.ACCEPThomeFROMENVIRONMENT"HOME"DISPLAYhome**> Method 2.DISPLAY"HOME"UPONENVIRONMENT-NAMEACCEPThomeFROMENVIRONMENT-VALUEGOBACK.
forvar_namein['PATH','HOME','LANG','USER']console.logvar_name,process.env[var_name]
Access to environment variables isn't a part of the Common Lisp standard, but most implementations provide some way to do it.
(lispworks:environment-variable"USER")
(sb-ext:posix-getenv"USER")
(ccl:getenv"USER")
(getenv"HOME")
Ways to do this in some other implementations are listed in theCommon Lisp Cookbook.
importstd.stdio,std.process;voidmain(){autohome=getenv("HOME");}
importtango.sys.Environment;voidmain(){autohome=Environment("HOME");}
programEnvironmentVariable;{$APPTYPE CONSOLE}usesSysUtils;beginWriteLn('Temp = '+GetEnvironmentVariable('TEMP'));end.
SELECT getenv('HOME'), getenv('USER');┌────────────────┬────────────────┐│ getenv('HOME') │ getenv('USER') ││ varchar │ varchar │├────────────────┼────────────────┤│ /Users/peter │ peter │└────────────────┴────────────────┘<unsafe:java.lang.System>.getenv("HOME")The featureget 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 makeget available.
classAPPLICATIONinheritEXECUTION_ENVIRONMENTcreatemakefeature{NONE}-- Initializationmake-- Retrieve and print value for environment variable `USERNAME'.doprint(get("USERNAME"))endend
System.get_env("PATH")
(getenv"HOME")
fun showVariable ← <text variable|writeLine(variable, ": '", Runtime.get(variable), "'")showVariable("SystemDrive")showVariable("USERNAME")# we can get the environment variables as a mapMap variables ← Runtime.variables()writeLine(variables["TEMP"])SystemDrive: 'C:'USERNAME: 'XXXYYY'C:\Users\xxxyyy\AppData\Local\Temp
os:getenv("HOME").
puts(1,getenv("PATH"))openSystem[<EntryPoint>]letmainargs=printfn"%A"(Environment.GetEnvironmentVariable("PATH"))0
"HOME"os-envprint
s"HOME"getenvtype
programshow_homeimplicit nonecharacter(len=32)::home_val! The string value of the variable HOMEinteger::home_len! The actual length of the valueinteger::stat! The status of the value:! 0 = ok! 1 = variable does not exist! -1 = variable is not long enought to hold the resultcallget_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 ifend programshow_home
' FB 1.05.0 Win64Varv=Environ("SystemRoot")PrintvSleep
C:\WINDOWS
callJava["java.lang.System", "getenv", ["HOME"]]
/home/frink
println( System.getenv('PATH') )println( $home )println( $user )include "NSLog.incl"NSLog(@"%@",fn NSUserName)NSLog(@"%@",fn NSFullUserName)NSLog(@"%@",fn NSHomeDirectory)NSLog(@"%@",fn NSTemporaryDirectory)HandleEvents
packagemainimport("fmt""os")funcmain(){fmt.Println(os.Getenv("SHELL"))}
/bin/bash
Library function os.Environ returns all environment variables. You're on your own then to parse out the one you want. Example:
packagemainimport("fmt""os""strings")funcmain(){s:="SHELL"se:=s+"="for_,v:=rangeos.Environ(){ifstrings.HasPrefix(v,se){fmt.Println(s,"has value",v[len(se):])return}}fmt.Println(s,"not found")}
SHELL has value /bin/bash
Commandget env fetches an environment variable into a synonym (a string)
get env \foo HOMEshow "\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"
System.getenv().each{property,value->println"$property = $value"}
importSystem.Environmentmain=dogetEnv"HOME">>=print-- get env vargetEnvironment>>=print-- get the entire environment as a list of (key, value) pairs
println env "HOME"println env "PATH"println env "USER"
CHARACTER string*255string = "PATH="SYSTEM(GEteNV = string)
software {print(load("$HOME"))print(load("$USER"))print(load("$PATH"))}proceduremain(arglist)if*envars=0thenenvars:=["HOME","TRACE","BLKSIZE","STRSIZE","COEXPSIZE","MSTKSIZE","IPATH","LPATH","NOERRBUF"]everyv:=!sort(envars)dowrite(v," = ",image(getenv(v))|"* not set *")end
2!:5'HOME'
System.getenv("HOME")// get env varSystem.getenv()// get the entire environment as a Map of keys to values
The JavaScript language has no facilities to access the computer: it relies on the host environment to provide it.
varshell=newActiveXObject("WScript.Shell");varenv=shell.Environment("PROCESS");WScript.echo('SYSTEMROOT='+env.item('SYSTEMROOT'));
"HOME" getenv.
env.HOME
If the environment variable name has spaces or special characters, the name must be given as a string, e.g.env."HOME".
The JsiUtil module provides access to setUtil.setenv(name, value) and getUtil.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"));varenvironment=Util.getenv();puts(environment.PATH);
@showENV["PATH"]@showENV["HOME"]@showENV["USER"]
_getenv"HOME"
// version 1.0.6// tested on Windows 10funmain(args:Array<String>){println(System.getenv("SystemRoot"))}
C:\WINDOWS
writeln "HOME: ", _env'HOMEwriteln "PATH: ", _env'PATHwriteln "USER: ", _env'USER
#!/usr/bin/lasso9definegetenv(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'))
/Users/rosetta/opt/local/bin:/opt/local/sbin:/usr/local/bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/X11/binrosetta
print StartupDir$print DefaultDir$
print GetEnvironmentVariable$("USERNAME") print GetEnvironmentVariable$("USERPROFILE") ' equivalent to UNIX HOME variable print GetEnvironmentVariable$("PATH") endfunction 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 selectend functionLIL does not ship with a command to retrieve process environment variables. Thesystem command could be used, but here is an extension in C for the lil shell.
staticLILCALLBACKlil_value_tfnc_env(lil_tlil,size_targc,lil_value_t*argv){if(!argc)returnNULL;returnlil_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 toenv, 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.
prompt$ makecc -c -g3 -std=c99 -pedantic -Wall -Wextra -Wno-format -Wno-long-long -Wno-unused-parameter main.c -o main.occ -g -L. -o lil main.o -llil -lmprompt$ lilLittle Interpreted Language Interactive Shell# env TERMxterm-256color
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 ifUsing the standard library:
os::environment_variable('PATH',Path).
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());}}
llGetTimestamp()=2012-07-18T01:26:12.133137ZllGetEnergy()=1.230000llGetFreeMemory()=16000llGetMemoryLimit()=65536
print(os.getenv("PATH"))
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}CheckitMake variables are initialized from the environment, so simply
TARGET=$(HOME)/some/thing.txtfoo: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 charactersOME.
H=oops...bar:echo$HOME# prints oops ... OME
getenv("PATH");Environment["PATH"]
getenv('HOME')getenv('PATH')getenv('USER')
:- 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) ).$PATH
MODULEEnvVarsEXPORTSMain;IMPORTIO,Env;VARk,v:TEXT;BEGINIO.Put(Env.Get("HOME")&"\n");FORi:=0TOEnv.Count-1DOEnv.GetNth(i,k,v);IO.Put(k&" = "&v&"\n")ENDENDEnvVars.
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")
When NetRexx runs under a JVM, system ENVIRONMENT variables are complimented by JVM system properties. This sample shows how to get both.
/* NetRexx */optionsreplaceformatcommentsjavacrossrefsymbolsnobinaryrunSample(arg)return--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~methodsysEnvironment(vn='')publicstaticifvn.length>0thendoenvName=vnenvValu=System.getenv(envName)ifenvValu=nullthenenvValu=''sayenvName'='envValuendelsedoenvVars=System.getenv()key=StringloopkeyoverenvVars.keySet()envName=keyenvValu=StringenvVars.get(key)sayenvName'='envValuendkeyendreturn--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~methodsysProperties(vn='')publicstaticifvn.length>0thendopropName=vnpropValu=System.getProperty(propName)ifpropValu=nullthenpropValu=''saypropName'='propValuendelsedosysProps=System.getProperties()key=StringloopkeyoversysProps.keySet()propName=keypropValu=sysProps.getProperty(key)saypropName'='propValuendkeyendreturn--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~methodrunSample(arg)publicstaticparseargevpv.ifev=''thenev='CLASSPATH'ifpv=''thenpv='java.class.path'say'-'.left(80,'-').overlay(' Environment "'ev'" ',5)sysEnvironment(ev)say'-'.left(80,'-').overlay(' Properties "'pv'" ',5)sysProperties(pv)saysay'-'.left(80,'-').overlay(' Environment ',5)sysEnvironment()say'-'.left(80,'-').overlay(' Properties ',5)sysProperties()sayreturn
---- 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/nrxuserHISTCONTROL = ignoredupsUSER = nrxuserZBASHRC = 1COMMAND_MODE = unix2003CLASSPATH = /usr/local/NetRexx/runlib/NetRexxR.jar:.SHELL = /bin/bash. . .---- Properties ----------------------------------------------------------------java.vm.specification.name = Java Virtual Machine Specificationsun.cpu.endian = littlesun.io.unicode.encoding = UnicodeBigsun.os.patch.level = unknownfile.separator = /java.vendor = Oracle Corporationsun.java.launcher = SUN_STANDARDjava.specification.vendor = Oracle Corporationuser.home = /Users/nrxuserjava.class.path = /usr/local/NetRexx/runlib/NetRexxR.jar:.java.vm.vendor = Oracle Corporationjava.runtime.name = Java(TM) SE Runtime Environment. . .
>(env"SHELL")"/bin/zsh">(env"TERM")"xterm"
importosechogetEnv("HOME")
While common environment variables exist as constants within the NSIS script compilation environment(see NSIS documentation), arbitrarily-named environment variables' values may be retrieved usingExpandEnvStrings.
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.
$env.HOME
[[NSProcessInfo processInfo] environment] returns anNSDictionary of the current environment.
[[[NSProcessInfoprocessInfo]environment]objectForKey:@"HOME"]
Sys.getenv"HOME"
System getEnv("PATH") println{System.showInfo "This is where Mozart is installed: "#{OS.getEnv 'OZHOME'}}getenv("HOME")externstr("echo $HOME")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
##system.Environment.GetEnvironmentVariable('TEMP').Println;
The%ENV hash maps environment variables to their values:
print$ENV{HOME},"\n";
ThePOSIXmodule also hasgetenv() which is the same thing as a function.
usePOSIX'getenv';printgetenv("HOME"),"\n";
withoutjs-- none such in a browser, that I know of?getenv("PATH")
/# Rosetta Code problem: http://rosettacode.org/wiki/Environment_variablesby Galileo, 10/2022 #/def getenv" > output.txt" chain cmd if "Error!" else "output.txt" "r" fopen dup fgets swap fclose endifenddef"path" getenv print
The$_ENV associative array maps environmental variable names to their values:
$_ENV['HOME']
: (sys "TERM")-> "xterm": (sys "SHELL")-> "/bin/bash"
write("%s\n",getenv("SHELL"));
/bin/bash
Environment variables can be found in the Env: drive and are accessed using a special variable syntax:
$Env:PathTo get a complete listing of all environment variables one can simply query the appropriate drive for its contents:
Get-ChildItemEnv:
SWI-Prolog has the built in functiongetenv.
?- getenv('TEMP', Temp).PureBasic has the built in funtion
GetEnvironmentVariable("Name")
Example
IfOpenConsole()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
Theos.environ dictionary maps environmental variable names to their values:
importosos.environ['HOME']
Sys.getenv("PATH")
#langracket(getenv"HOME")
(formerly Perl 6)
The%*ENV hash maps environment variables to their values:
say%*ENV<HOME>;
printget-env"HOME"
here "HOME" getEnvhere puts
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
for the DOS shell under Microsoft Windows (any version).
(Also successfully tested with Regina under the bash shell in UNIX.)
/*REXX program shows how to get an environmental variable under Windows*/x=value('TEMP',,'SYSTEM')
The following will work for
for the DOS shell under Microsoft Windows (any version).
(Also successfully tested with Regina and ooRexx under the bash shell in UNIX.)
/*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:
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:
As such, CMS has its own command interface for these variables.
see get("path")TheENV hash maps environment variable names to their values:
ENV['HOME']
' ------- 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 eventprint "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.11Platform is : win32Url Keys is : noneUser Address is: 127.0.0.1Event Key is : noneDefault Dir is : c:\rbp101usestd::env;fnmain(){println!("{:?}",env::var("HOME"));println!();for(k,v)inenv::vars().filter(|(k,_)|k.starts_with('P')){println!("{}: {}",k,v);}}
Ok("/root")PATH: /root/.cargo/bin:/root/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binPLAYGROUND_EDITION: 2018PLAYGROUND_TIMEOUT: 10PWD: /playgroundNote thatvar_os andvars_os are also available, which produceOsString instead ofString, offering compatibility with non-utf8 systems.
sys.env.get("HOME")
Seed7 provides the functiongetenv,to get the value of an environment variable. Environment variables are highly operating systemdependent. Some variables such as HOME are not always defined and others like PATH usean operating system dependent format (different delimiters). Seed7 provides the functionshomeDir andgetSearchPathto 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;TheENV hash maps environment variables to their values:
sayENV{'HOME'};
Environment variables at: 'PATH'."==> '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games'"
(env "HOME")
Use theOSProcess library to gain access to environment variables:
OSProcessthisOSProcessenvironmentat:#HOME.OSProcessthisOSProcessenvironmentat:#PATH.OSProcessthisOSProcessenvironmentat:#USER.
The host(4) function returns a known environment variable.
output = host(4,'PATH')end
OS.Process.getEnv"HOME"
returns an option type which is either SOME value or NONE if variable doesn't exist
Use theenvextended macro function.
display"`:env PATH'"display"`:env USERNAME'"display"`:env USERPROFILE'"
print("USER:\(ProcessInfo.processInfo.environment["USER"]??"Not set")")print("PATH:\(ProcessInfo.processInfo.environment["PATH"]??"Not set")")
ASK#1:ACCESStype$ASKBACKredASKCOLORredASKCOLORMIX(2)red,green,blueASKCURSORvble1,vble2ASK#2:DATUMtype$ASKDIRECTORYdir$ASK#3:ERASABLEtype$ASK#4:FILESIZEvble09ASK#5:FILETYPEvble10ASKFREEMEMORYvble11ASK#61:MARGINvble12ASKMAXCOLORvble13ASKMAXCURSORvble1,vble2ASKMODEvble15$ASKNAMEvble16$ASK#7:ORGANIZATIONvble17$ASKPIXELSvble1,vble2ASK#8:POINTERvble19$ASK#9:RECORDvble20ASK#1:RECSIZEvble21ASK#2:RECTYPEvble22$ASKSCREENvble1,vble2,vble3,vble4ASK#3:SETTERvble24$ASKTEXTJUSTIFYvble1$,vble2$ASKWINDOWvble1,vble2,vble3,vble4ASK#4:ZONEWIDTHvble27
Theenv global array maps environmental variable names to their values:
$env(HOME)
TXR can treat the environment vector as text stream:
@(next :env)@(collect)@VAR=@VAL@(end)
A recently addedgather 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=@homeUSER=@userPATH=@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), butshell 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=@homeUSER=@userPATH=@pathSHELL=@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 viamapcar.
Platform note: On POSIX, environment variables, which are extracted usingextern char **environ are assumed to contain UTF-8. On Windows, theGetEnvironmentStringsW function is used to obtain the environment vector as wide character data.
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 theexport command:
export VAR
Now child processes launched by the shell will have an environment variable calledVAR.
The Unix command "env" will print out all of the environment variables as key=value pairs on standard output.
import "system"out (system.getenv "HOME") endl console
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'}*~+ ~environsThe rest of this application searches for the three variables named and displays them on standard output.
$ showenv< 'TERM': 'Eterm', 'SHELL': '/bin/bash', 'X11BROWSER': '/usr/bin/firefox'>
// Environment variables in V// v run environment_variables.vmodule mainimport ospub fn main() { print('In the $os.environ().len environment variables, ') println('\$HOME is set to ${os.getenv('HOME')}')}prompt$ v run environment-variables.vIn the 64 environment variables, $HOME is set to /home/btiffin
Get_Environment(10,"PATH")Message(@10)
Or with short keywords:
GE(10,"PATH") M(@10)
Debug.Print Environ$("PATH")Uses the 'os' sub-module.
import "os" for EnvironSystem.print(Environ.get("SHELL"))/bin/bash
This task was particularly worthwhile because it revealed a discrepancyin the way 32-bit XPL0 accessed the environment block. A small mod toTran's PMODE.ASM DPMI was required to make the 32-bit protected-modeversion work the same as the 16-bit real-mode versions.
include c:\cxpl\codes; \intrinsic 'code' declarationsstring 0; \use zero-terminated stringsint CpuReg, PspSeg, EnvSeg, I, J, C;char EnvVar;[CpuReg:= GetReg; \access CPU registersPspSeg:= CpuReg(9); \get segment address of our PSPEnvSeg:= Peek(PspSeg,$2C) + Peek(PspSeg,$2D)<<8;EnvVar:= "PATH"; \environment variableI:= 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 ];]
PATH=\masm6;C:\;C:\CXPL;C:\UTIL;C:\DOS;C:\BORLANDC\BIN
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.
System.getenv("HOME")/home/craigdSystem.getenv() //--> Dictionary of all env vars