How sensible is ... ?

How sensible is ... ?

[Phil Pennock]

How good an idea would it be to add a shell-callable context builtin, or
a shell variable, to tell whether something is being run directly or as
a function call?  (I could be displaying ignorance of something that's
already there, I suppose)

Eg, have a directory of zsh scripts, which start:
#!/bin/zsh -f
case $context in
 toplevel) alias leave=exit ;;
 function) alias leave=return ;;
esac

the scripts could then be written such that zsh users could autoload
them and others could run them and get the same effective results.

These would of course be tricky, but I feel potentially more useful for
system administrators who want to provide a bunch of small fast
utilities for ALL users.

I don't particularly want to have to litter a directory with 5-line
scripts which always require fork-exec, I'd rather have a special
directory containing files as per above and have the relevant system
initialisation scripts sort out which PATH/FPATH it should go in.

Feedback welcome
-- 
--> Phil Pennock ; GAT d- s+:+ a23 C++(++++) UL++++/I+++/S+++/H+ P++@ L+++
E-@ W(+) N>++ o !K w--- O>+ M V !PS PE Y+ PGP+ t-- 5++ X+ R !tv b++>+++ DI+ D+
G+ e+ h* r y?

Re: How sensible is ... ?

[Phil Pennock]

Following up to myself (sorry):
> Eg, have a directory of zsh scripts, which start:
> #!/bin/zsh -f
> case $context in
>  toplevel) alias leave=exit ;;
>  function) alias leave=return ;;
> esac

Actually, I've just thought of [[ -o interactive ]] -- always the way.

Is this a sufficient test?  It /seems/ to work as I want ...
-- 
--> Phil Pennock ; GAT d- s+:+ a23 C++(++++) UL++++/I+++/S+++/H+ P++@ L+++
E-@ W(+) N>++ o !K w--- O>+ M V !PS PE Y+ PGP+ t-- 5++ X+ R !tv b++>+++ DI+ D+
G+ e+ h* r y?

Re: How sensible is ... ?

[Peter Stephenson]

Phil Pennock wrote:
> > #!/bin/zsh -f
> > case $context in
> >  toplevel) alias leave=exit ;;
> >  function) alias leave=return ;;
> > esac
> 
> Actually, I've just thought of [[ -o interactive ]] -- always the way.
> 
> Is this a sufficient test?  It /seems/ to work as I want ...

In this particular case, you don't need it, since return will function
like exit in a script.

I've thought of a hack which is pretty much guaranteed to work (I
think):

  foo=global
  local foo >/dev/null
  if [[ $foo = global ]]; then 
    print At top level
  else
    print Inside a function
  fi

The nasty bit is the `local foo' which prints the status of $foo if it
already exists.  I keep thinking we ought to do something about that.

-- 
Peter Stephenson <pws@ibmth.df.unipi.it>       Tel: +39 050 844536
WWW:  http://www.ifh.de/~pws/
Dipartimento di Fisica, Via Buonarroti 2, 56127 Pisa, Italy

Re: How sensible is ... ?

[Phil Pennock]

Typing away merrily, Peter Stephenson produced the immortal words:
> > Is this a sufficient test?  It /seems/ to work as I want ...
> 
> In this particular case, you don't need it, since return will function
> like exit in a script.

*doh*

>   foo=global
>   local foo >/dev/null
>   if [[ $foo = global ]]; then 
>     print At top level
>   else
>     print Inside a function
>   fi

I found that using 'alias' inside there failed to work (in an autoloaded
function anyway) and had to convert to a function.  And useing 'typeset
-f leavecmd' then defining it after a possible 'setopt localfunctions',
it remained in scope. I'm at work and decided against spending more time
on that so just used TRAPEXIT to unfunction it -- maybe I'm just doing
something wrong ...

All this just for a really nice version of xtitle ...
-- 
--> Phil Pennock ; GAT d- s+:+ a23 C++(++++) UL++++/I+++/S+++/H+ P++@ L+++
E-@ W(+) N>++ o !K w--- O>+ M V !PS PE Y+ PGP+ t-- 5++ X+ R !tv b++>+++ DI+ D+
G+ e+ h* r y?

Re: How sensible is ... ?

[Peter Stephenson]

Phil Pennock wrote:
> I found that using 'alias' inside there failed to work (in an autoloaded
> function anyway) and had to convert to a function.

That's a general feature.

% testal() { al='print alias'; al; }
% testal
zsh: command not found: al

The entire function is parsed before the alias is defined, so the `al'
never gets expanded.  A script is parsed line by line, so this doesn't
happen.

> And useing 'typeset
> -f leavecmd' then defining it after a possible 'setopt localfunctions',
> it remained in scope. I'm at work and decided against spending more time
> on that so just used TRAPEXIT to unfunction it -- maybe I'm just doing
> something wrong ...

I don't think there is another way of making functions have local
scope at the moment.

-- 
Peter Stephenson <pws@ibmth.df.unipi.it>       Tel: +39 050 844536
WWW:  http://www.ifh.de/~pws/
Dipartimento di Fisica, Via Buonarroti 2, 56127 Pisa, Italy

Re: How sensible is ... ?

[Bart Schaefer]

Gotta stay up all night to keep up with these discussions nowadays ...

On Jan 13, 10:26am, Phil Pennock wrote:
} Subject: How sensible is ... ?
}
} How good an idea would it be to add a shell-callable context builtin, or
} a shell variable, to tell whether something is being run directly [...]
} the scripts could then be written such that zsh users could autoload
} them and others could run them and get the same effective results.

On Jan 13, 12:17pm, Peter Stephenson wrote:
} Subject: Re: How sensible is ... ?
}
} In this particular case, you don't need it, since return will function
} like exit in a script.

That's 99.9% right. :-)  In zsh, return will function like exit, but in
other shells you just get "return: command not found" or the equivalent.
If you want to write a script that can be executed by sh/bash/ksh and
still be autoloaded by zsh, you need to use something like

	return $? 2>/dev/null || exit $?

On Jan 13, 11:09am, Phil Pennock wrote:
} Subject: Re: How sensible is ... ?
}
} Actually, I've just thought of [[ -o interactive ]] -- always the way.
} 
} Is this a sufficient test?  It /seems/ to work as I want ...

It won't work if you call your function from `zsh -c ...` and possibly
not in a few other cases as well (though that test should always be OK
whenever you have a shell prompt).

On Jan 13, 12:17pm, Peter Stephenson wrote:
} I've thought of a hack which is pretty much guaranteed to work (I
} think):
} 
}   foo=global
}   local foo >/dev/null
}   if [[ $foo = global ]]; then 
}     print At top level
}   else
}     print Inside a function
}   fi
} 
} The nasty bit is the `local foo' which prints the status of $foo if it
} already exists.  I keep thinking we ought to do something about that.

I don't have ksh handy, but `foo=bar;local foo` in bash produces the error
message "bash: local: can only be used in a function" unless you are in a
function, in which case it produces nothing.

-- 
Bart Schaefer                                 Brass Lantern Enterprises
http://www.well.com/user/barts              http://www.brasslantern.com

Re: How sensible is ... ?

[Phil Pennock]

Typing away merrily, Bart Schaefer produced the immortal words:
> I don't have ksh handy, but `foo=bar;local foo` in bash produces the error
> message "bash: local: can only be used in a function" unless you are in a
> function, in which case it produces nothing.

On SunOS 5.5.1 ksh that is accepted at top level.
No error.
-- 
--> Phil Pennock ; GAT d- s+:+ a23 C++(++++) UL++++/I+++/S+++/H+ P++@ L+++
E-@ W(+) N>++ o !K w--- O>+ M V !PS PE Y+ PGP+ t-- 5++ X+ R !tv b++>+++ DI+ D+
G+ e+ h* r y?