bash: experiment to save and restore global variable context

Question

I made a small experiment to save in one line some context.

It works exactly as I wanted. So this post is: 1. to share it with the community. 2. to improve it, or have a complete other solution because it is ugly and cryptic.

The situation is the following : there is a global variable and I want locally in functions to be able to change it and restore it at the end:

x()
{
    typeset loc=$glob
    glob=<val>
    (...)
    glob=$loc
}

This is too verbose for me, and asking for typos.

So I tried this (code ready to use):

#!/bin/bash

glob=1
indent=0

# appliance
trace()
{
   printf "%$((${indent}*3))s %s\n" "" "$1"
}

# the context stuff (creation and destruction)
# in variable, because with a function, I'd need to create a $(sub shell) and it wouldn't work
new_glob='trap restore_context RETURN;typeset loc=$glob;glob'

restore_context()
{
   res=$?
   glob=$loc
   trap - RETURN
}

# common test stuff, to isolate the traces
test_call()
{
   typeset res
   trace "in ${FUNCNAME[1]}, before $1,glob=$glob"
   (( indent++ ))
   eval $1
   res=$?
   (( indent-- ))

   trace "in ${FUNCNAME[1]}, res of $1=$res"
   trace "in ${FUNCNAME[1]}, after $1,glob=$glob"

   return $res
}

# Russian dolls function
f()
{
   eval "$new_glob=6"
   test_call g
   return 16
}

g()
{
   eval "$new_glob=7"
   test_call h
   return 17
}

h()
{
   eval "$new_glob=8"
   trace "in h, glob=$glob"
   i
   return 18
}

i()
{
   trace "in i, glob=$glob"
}

# main
test_call f

Here the script calls f, which calls g, which call h. Each function changes the global variable and then restore it.

Output:

# ./test_rtrap
 in main, before f,glob=1
    in f, before g,glob=6
       in g, before h,glob=7
          in h, glob=8
          in i, glob=8
       in g, res of h=18
       in g, after h,glob=7
    in f, res of g=17
    in f, after g,glob=6
 in main, res of f=16
 in main, after f,glob=1

The important point here is that function i() prints 8, and not 1, as using local variables would do.

To reach this result, I use a trap function on RETURN.

Now the above function x simply becomes:

x()
{
   eval "$new_glob=6"
   (...)
}

That's a pity that I had to use an eval and a variable containing (part of) code. It is not natural, quite cryptic. But I needed it because using a function there would have required a subshell, with the related variables context issues.

So, not perfect, not very beautiful, but less verbose, and it works.

Is there a better way to perform this, than the ugly eval "$new_glob=6"

Answer 1

Way way over the top! At least for the example shown.

Replace the eval "$new_glob=6" with local glob=6 and get rid of the new_glob variable.

In other words rather than writing

x()
{
   typeset loc=$glob
   glob=<val>
   (...)
   glob=$loc
}

just write

x()
{
   typeset glob
   glob=<val>
}

optionally replacing typeset with local or declare.

Bash is a dynamically scoped language. Currently in the linked article it describes one implementation strategy

An even simpler implementation is the representation of dynamic variables with simple global variables. The local binding is performed by saving the original value in an anonymous location on the stack that is invisible to the program. When that binding scope terminates, the original value is restored from this location. In fact, dynamic scope originated in this manner. Early implementations of Lisp used this obvious strategy for implementing local variables, and the practice survives in some dialects which are still in use, such as GNU Emacs Lisp.

which pretty much describes the bash code provided.

Answer 2

OK (thanks Icarus), so IMHO bash is really weird here. I essentially re-implemented its behavior.

Local variable in bash are NOT local !! They just locally change/set the value of global/environment variables and restore their value upon exit of the functions where they are """locally defined""". This is called dynamic scoping.

Local in bash means "local value of a global variable", which is weird (for me). For example, ksh93 behave differently, a local variable being really a local variable (i.e. hiding the global one). This is called lexical/dynamic scoping and, by far, most languages use this.

To illustrate this, I wrote another test program:

if (( $# == 0 )); then
   # run this script with specified shells
   bash -c "$0 -c"
   ksh93 -c "$0 -c"
   exit 0
fi

# which shell am I
readlink /proc/$$/exe

# declarations
local="Dynamic scoping"          # i.e. func i view "local" value
global="Lexical/Static scoping"  # i.e. func i views "global" value

glob="$global"

# non POSIX declarations
function f { typeset glob="$local"; i; }
function i { echo "      $glob"; }

# call
echo "   non POSIX ( function f )"
f

# POSIX declations
pf() { typeset glob="$local"; i; }
pi() { echo "      $glob"; }

# call
echo "   POSIXi ( f() )"
pf

Syntactically, these instructions/script run on both bash and ksh93.

Function f defines a local variable, and calls i. In lexical scoping situations, function i has access to the global variable, since it is defines lexically out of function f scope. In dynamic scoping, no local variable is created, only the global variable is created, function f only setting its value during its own execution lifetime. When function i is called, function f still "lives", so the value global variable value still has value assigned function f. Only upon function f return, the shell will restore the value that the function changed.

Here is its output:

/u-blox/gallery/ubx/det/re6_64/8.0/bin/bash
   non POSIX ( function f )
      Dynamic scoping
   POSIXi ( f() )
      Dynamic scoping
/bin/ksh93
   non POSIX ( function f )
      Lexical/Static scoping
   POSIXi ( f() )
      Dynamic scoping

Now, the question is: how to implement lexical scoping in bash? ;-)