I think that you could use $BASH_SOURCE variable. It returns path that was executed:

pbm@tauri ~ $ /home/pbm/a.sh 

/home/pbm/a.sh

pbm@tauri ~ $ ./a.sh

./a.sh

pbm@tauri ~ $ source /home/pbm/a.sh 

/home/pbm/a.sh

pbm@tauri ~ $ source ./a.sh

./a.sh

So in next step we should check if path is relative or not. If it's not relative everything is ok. If it is we could check path with pwd, concatenate with / and $BASH_SOURCE.

For thoroughness and the sake of searchers, here is what these do...
It is a community wiki, so feel free to add other shell's equivalents (obviously, $BASH_SOURCE will be different).

test.sh:

#! /bin/sh

called=$_

echo $called

echo $_

echo $0

echo $BASH_SOURCE

test2.sh:

#! /bin/sh

source ./test.sh

Bash:

$./test2.sh

./test2.sh

./test2.sh

./test2.sh

./test.sh

$ sh ./test2.sh

/bin/sh

/bin/sh

./test2.sh

./test.sh

Dash

$./test2.sh

./test2.sh

./test2.sh

./test2.sh



$/bin/sh ./test2.sh

/bin/sh

/bin/sh

./test2.sh



$

Zsh

$ ./test2.sh

./test.sh

./test.sh

./test.sh



$ zsh test.sh



echo

test.sh



$

This solution applies only to bash and not tcsh. Note that the commonly supplied answer ${BASH_SOURCE[0]} won't work if you try to find the path from within a function.

I've found this line to always work, regardless of whether the file is being sourced or run as a script.

echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

If you want to follow symlinks use readlink on the path you get above, recursively or non-recursively.

Here's a script to try it out and compare it to other proposed solutions. Invoke it as source test1/test2/test_script.sh or bash test1/test2/test_script.sh.

#

# Location: test1/test2/test_script.sh

#

echo $0

echo $_

echo ${BASH_SOURCE}

echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}



cur_file="${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}"

cur_dir="$(dirname "${cur_file}")"

source "${cur_dir}/func_def.sh"



function test_within_func_inside {

    echo ${BASH_SOURCE}

    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

}



echo "Testing within function inside"

test_within_func_inside



echo "Testing within function outside"

test_within_func_outside



#

# Location: test1/test2/func_def.sh

#

function test_within_func_outside {

    echo ${BASH_SOURCE}

    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

}

The reason the one-liner works is explained by the use of the BASH_SOURCE environment variable and its associate FUNCNAME.

BASH_SOURCE

An array variable whose members are the source filenames where the corresponding shell function names in the FUNCNAME array variable are defined. The shell function ${FUNCNAME[$i]} is defined in the file ${BASH_SOURCE[$i]} and called from ${BASH_SOURCE[$i+1]}.

FUNCNAME

An array variable containing the names of all shell functions currently in the execution call stack. The element with index 0 is the name of any currently-executing shell function. The bottom-most element (the one with the highest index) is "main". This variable exists only when a shell function is executing. Assignments to FUNCNAME have no effect and return an error status. If FUNCNAME is unset, it loses its special properties, even if it is subsequently reset.

This variable can be used with BASH_LINENO and BASH_SOURCE. Each element of FUNCNAME has corresponding elements in BASH_LINENO and BASH_SOURCE to describe the call stack. For instance, ${FUNCNAME[$i]} was called from the file ${BASH_SOURCE[$i+1]} at line number ${BASH_LINENO[$i]}. The caller builtin displays the current call stack using this information.

[Source: Bash manual]

This worked for me in bash, dash, ksh, and zsh:

if test -n "$BASH" ; then script=$BASH_SOURCE

elif test -n "$TMOUT"; then script=${.sh.file}

elif test -n "$ZSH_NAME" ; then script=${(%):-%x}

elif test ${0##*/} = dash; then x=$(lsof -p $$ -Fn0 | tail -1); script=${x#n}

else script=$0

fi



echo $script

Output for these shells:

BASH source: ./myscript

ZSH source: ./myscript

KSH source: /home/pbrannan/git/theme/src/theme/web/myscript

DASH source: /home/pbrannan/git/theme/src/theme/web/myscript

BASH: ./myscript

ZSH: ./myscript

KSH: /home/pbrannan/git/theme/src/theme/web/myscript

DASH: ./myscript

I tried to make it work for csh/tcsh, but it's too hard; I'm sticking to POSIX.

I was a bit confused by the community wiki answer (from Shawn J. Goff), so I wrote a script to sort things out. About $_, I found this: Usage of _ as an environment variable passed to a command. It's an environment variable so it's easy to test its value incorrectly.

Below is the script, then it's output. They also are in this gist.

test-shell-default-variables.sh

#!/bin/bash



# test-shell-default-variables.sh



# Usage examples (you might want to `sudo apt install zsh ksh`):

#

#  ./test-shell-default-variables.sh dash bash

#  ./test-shell-default-variables.sh dash bash zsh ksh

#  ./test-shell-default-variables.sh dash bash zsh ksh | less -R



# `-R` in `less -R` to have less pass escape sequences directly to the terminal

# so we have colors.





# The "invoking with name `sh`" tests are commented because for every shell I

# tested (dash, bash, zsh and ksh), the output was the same as that of dash.



# The `test_expression` function also work with expansion changes. You can try

# lines like `test_expression '{BASH_SOURCE:-$0}'`.



echolor() {

    echo -e "e[1;36m$@e[0m"

}



tell_file() {

    echo File `"$1"` is:

    echo ```

    cat "$1"

    echo ```

    echo

}



SHELL_ARRAY=("$@")



test_command() {

    for shell in "${SHELL_ARRAY[@]}"

    do

        prepare "$shell"

        cmd="$(eval echo $1)"

        # echo "cmd: $cmd"

        printf '%-4s: ' "$shell"

        { env -i $cmd 2>&1 1>&3 | sed 's/^/[err]/'; } 3>&1

        teardown

    done

    echo

}



prepare () {

    shell="$1"

    PATH="$PWD/$shell/sh:$PATH"

}



teardown() {

    PATH="${PATH#*:}"

}





###

### prepare

###

for shell in "${SHELL_ARRAY[@]}"

do

    mkdir "$shell"

    ln -sT "/bin/$shell" "$shell/sh"

done



echo > printer.sh

echo '. ./printer.sh' > sourcer.sh

rm linked.sh &>/dev/null; ln -sT "printer.sh" "linked.sh"



tell_file sourcer.sh



###

### run

###

test_expression() {

    local expr="$1"



    # prepare

    echo "echo $expr" > printer.sh

    tell_file printer.sh



    # run

    cmd='$shell ./printer.sh'

    echolor "`$cmd` (simple invocation) ($expr):"

    test_command "$cmd"



    # cmd='sh ./printer.sh'

    # echolor "`$cmd` (when executable name is `sh`) ($expr):"

    # test_command "$cmd"



    cmd='$shell ./sourcer.sh'

    echolor "`$cmd` (via sourcing) ($expr):"

    test_command "$cmd"



    # cmd='sh ./sourcer.sh'

    # echolor "`$cmd` (via sourcing, when name is `sh`) ($expr):"

    # test_command "$cmd"



    cmd='$shell ./linked.sh'

    echolor "`$cmd` (via symlink) ($expr):"

    test_command "$cmd"



    # cmd='sh ./linked.sh'

    # echolor "`$cmd` (via symlink, when name is `sh`) ($expr):"

    # test_command "$cmd"



    echolor "------------------------------------------"

    echo

}



test_expression '$BASH_SOURCE'

test_expression '$0'

test_expression '$(/bin/true x y; true a b c; echo $_)' # Rq: true is a builtin

test_expression '$_'



###

### teardown

###

for shell in "${SHELL_ARRAY[@]}"

do

    rm "$shell/sh"

    rm -d "$shell"

done



rm sourcer.sh

rm linked.sh

rm printer.sh

Output of ./test-shell-default-variables.sh {da,ba,z,k}sh

File `sourcer.sh` is:

```

. ./printer.sh

```



File `printer.sh` is:

```

echo $BASH_SOURCE

```



`$shell ./printer.sh` (simple invocation) ($BASH_SOURCE):

dash: 

bash: ./printer.sh

zsh : 

ksh : 



`$shell ./sourcer.sh` (via sourcing) ($BASH_SOURCE):

dash: 

bash: ./printer.sh

zsh : 

ksh : 



`$shell ./linked.sh` (via symlink) ($BASH_SOURCE):

dash: 

bash: ./linked.sh

zsh : 

ksh : 



------------------------------------------



File `printer.sh` is:

```

echo $0

```



`$shell ./printer.sh` (simple invocation) ($0):

dash: ./printer.sh

bash: ./printer.sh

zsh : ./printer.sh

ksh : ./printer.sh



`$shell ./sourcer.sh` (via sourcing) ($0):

dash: ./sourcer.sh

bash: ./sourcer.sh

zsh : ./printer.sh

ksh : ./sourcer.sh



`$shell ./linked.sh` (via symlink) ($0):

dash: ./linked.sh

bash: ./linked.sh

zsh : ./linked.sh

ksh : ./linked.sh



------------------------------------------



File `printer.sh` is:

```

echo $(/bin/true x y; true a b c; echo $_)

```



`$shell ./printer.sh` (simple invocation) ($(/bin/true x y; true a b c; echo $_)):

dash: 

bash: c

zsh : c

ksh : 



`$shell ./sourcer.sh` (via sourcing) ($(/bin/true x y; true a b c; echo $_)):

dash: 

bash: c

zsh : c

ksh : 



`$shell ./linked.sh` (via symlink) ($(/bin/true x y; true a b c; echo $_)):

dash: 

bash: c

zsh : c

ksh : 



------------------------------------------



File `printer.sh` is:

```

echo $_

```



`$shell ./printer.sh` (simple invocation) ($_):

dash: 

bash: bash

zsh : 

ksh : 



`$shell ./sourcer.sh` (via sourcing) ($_):

dash: 

bash: bash

zsh : ./printer.sh

ksh : 



`$shell ./linked.sh` (via symlink) ($_):

dash: 

bash: bash

zsh : 

ksh : 



------------------------------------------

What did we learn ?

$BASH_SOURCE

• 
  $BASH_SOURCE works in bash and only in bash.


• The only difference with $0 is when the current file was sourced by
  another file. In that case, $BASH_PROFILE contains the name of the
  sourced file, rather than that of the souring file.

$0

• In zsh, $0 has the same value as $BASH_SOURCE in bash.

$_

• 
  $_ is left untouched by dash and ksh.


• In bash and zsh, $_ decays to the last argument of the last call.


• bash initializes $_ to "bash".


• zsh leaves $_ untouched.
  (when sourcing, it`s just the result of the "last argument" rule).

Symlinks

• When a script is called through a symlink, no variable contains any
  reference to the destination of the link, only its name.

ksh

• Regarding those tests, ksh behaves like dash.

sh

• When bash or zsh is called through a symlink named sh, regarding those tests, it behave like dash.

For the bash shell, I found @Dennis Williamson's answer most helpful, but it didn't work in the case of sudo. This does:

if ( [[ $_ != $0 ]] && [[ $_ != $SHELL ]] ); then

    echo "I'm being sourced!"

    exit 1

fi

To make your script both bash- and zsh-compatible instead of using if statements you can simply write ${BASH_SOURCE[0]:-${(%):-%x}}. The resulting value will be taken from BASH_SOURCE[0] when it's defined, and ${(%):-%x}} when BASH_SOURCE[0] is not defined.

tl;dr script=$(readlink -e -- "${BASH_SOURCE}") (for bash obviously)

$BASH_SOURCE test cases

given file /tmp/source1.sh

echo '$BASH_SOURCE '"(${BASH_SOURCE})"

echo 'readlink -e $BASH_SOURCE'

     "($(readlink -e -- "${BASH_SOURCE}"))"

source the file in different manners

source from /tmp

$> cd /tmp



$> source source1.sh

$BASH_SOURCE (source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)



$> source ./source1.sh

$BASH_SOURCE (./source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)



$> source /tmp/source1.sh

$BASH_SOURCE (/tmp/source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)

source from /

cd /

$> source /tmp/source1.sh

$0 (bash)

$BASH_SOURCE (/tmp/source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)

source from different relative paths /tmp/a and /var

$> cd /tmp/a



$> source ../source1.sh

$BASH_SOURCE (../source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)



$> cd /var



$> source ../tmp/source1.sh

$BASH_SOURCE (../tmp/source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)

regarding $0

in all cases, if the script had the added command

echo '$0 '"(${0})"

then source the script always printed

$0 (bash)

however, if the script was run, e.g.

$> bash /tmp/source1.sh

then $0 would be string value /tmp/source1.sh.

$0 (/tmp/source1.sh)

$BASH_SOURCE (/tmp/source1.sh)

readlink -e $BASH_SOURCE (/tmp/source1.sh)

Actually, "dirname $0" will get you the path to the script, but you have to interpret it a bit:

$ cat bash0

#!/bin/bash

echo $0=$0

dirname $0

$ bash0    # "." appears in PATH right now.

$0=./bash0

.

$ ./bash0

$0=./bash0

.

$ $PWD/bash0

$0=/home/00/bediger/src/ksh/bash0

/home/00/bediger/src/ksh

$ $PWD/../ksh/bash0

$0=/home/00/bediger/src/ksh/../ksh/bash0

/home/00/bediger/src/ksh/../ksh

$ ../ksh/bash0

$0=../ksh/bash0

../ksh

You have to prepare to handle "." as the directory name under some common circumstances. I'd experiment a bit, as I remember the dirname built-in to ksh doing things a bit differently when "." appears in PATH.