Mdthbs

Is it possible to implement a local export in zsh? Possibly using try and always?

Does this create race-conditions?

By local export, I mean sth exactly like a local variable, that is accessible to the subprocesses (in scope).

Example:

function a() {

 local export YACY_TIMEOUT=60

 yacy -r -d sth

 }

 export YACY_TIMEOUT=4

 echo "$YACY_TIMEOUT" # 4

 a

 echo "$YACY_TIMEOUT" # 4

Use a subshell:

function a() (

 YACY_TIMEOUT=60

 yacy -r -d sth

)

Example:

% a () ( TIMEOUT=60; env | grep TIMEOUT )

% export TIMEOUT=4

% echo $TIMEOUT

4

% a

TIMEOUT=60

% echo $TIMEOUT

4

This doesn't do exactly what you want, as it doesn't actually create a new variable in the current shell:

a () {

    YACY_TIMEOUT=60 yacy -r -d std

}

This is the standard syntax for running a command and giving it a particular value of an environment variable. The variable YACY_TIMEOUT, if it exists in the same scope as the body of the a function, would not be modified.

This would work in any POSIX shell.

What this does not do is to allow you to use YACY_TIMEOUT with the "local" value inside the function before calling yacy.

In zsh or any other shell that supports local variables declared with local, you could do

a () {

    local YACY_TIMEOUT=60



    YACY_TIMEOUT=$YACY_TIMEOUT yacy -r -d sth

}

Here, YACY_TIMEOUT would be local to the a function. The injection of the variable as an environment variable in the yacy process happens as in the first example I gave, by preceding the invocation by an assignment.

Now YACY_TIMEOUT is both local and is also available in the yacy process' environment. This would work in any shell that supports using local to declare local variables.

Variables are always available to sub-processes. In:

a=1

(echo "$a")

you see 1.

I think what you meant is that you want the variable to have a local scope and be exported to the environment so that they are passed as environment variables to commands that are executed. The execution of a command is the thing that wipes the memory a process (and the environment is a way to preserve some data across it), forking a child copies the entire memory so everything is preserved.

For that, you can use local -x:

a=(1 2)

f() {

  local -x a=3

  typeset -p a

  printenv a # printenv being *executed*

}

f

typeset -p a

gives:

typeset -x a=3

3

typeset -a a=( 1 2 )

Or you can export it after having been declared local:

a=(1 2)

f() {

  local a=3

  export a

  typeset -p a

  printenv a # printenv being *executed*

}

f

typeset -p a

Note that you can pass a variable in the environment of a single command without defining it otherwise as a shell variable with:

a=(1 2)

f() {

  a=3 printenv a # printenv being *executed*

}

f

typeset -p a

Note that local originated in the Almquist shell in the late 80s, but works differently from zsh's. In the Almquist shell (and its descendants like dash and the sh of NetBSD/FreeBSD), local only affects the scope of a variable and doesn't change the value or attributes of a variable.

zsh's local works more like ksh93's typeset in that it declares a brand new variable that is independent from the one in the outer scope.

ksh88, bash and pdksh's local/typeset try to do that as well but still inherit some attributes from the variable of the outer scope including the export attribute. That changed in ksh93 though note that ksh93 also switched to static scoping and only implements local scope in functions declared with the function f { ...; } syntax.