How to find the file where a bash function is defined?

Question

I cannot figure out how to find the file where a bash function is defined (__git_ps1 in my case).

I experimented with declare, type, which, but nothing tells me the source file. I read somewhere that declare can print the file name and the line number, but it was not explained how. The help page for declare does not say it either.

How can I get this information?

Answer 1

If you are prepared to run the function, then you can get the information by using set -x to trace the execution and setting the PS4 variable.

1. Start bash with --debugger or else use shopt -s extdebug to record extra debugging info.

2. Set PS4, the 'prompt' printed when tracing to show the source line.

3. Turn on tracing.

4. you can then run your function and for each line you will get the filename of the function.

5. use set +x to turn off tracing.

So for this case you would run

bash --debugger
PS4='+ ${BASH_SOURCE[0]} '
set -x ; __git_ps1 ; set +x

Answer 2

If you are not willing to run the function, you can still set up debugging and get the information. The steps are

1. start bash --debugger or shopt -s extdebug before the function is defined.
2. declare -F __git_ps1

and it will report where the function is defined.

The advantages of this method compared to seeing the annotated execution trace with PS4 are

• A lot less output
• It directly answers the question

The advantages of the execution trace are

• See all called functions at once
• See the relations between called functions
• See recursion

I strongly recommend having shopt -s extdebug at the start of both ~/.bashrc and ~/.bash_profile to cover the different files used in different Invocation cases.

Answer 3

It doesn't seem to be possible in bash, but it is in zsh:

$ type __git_ps1
> __git_ps1 is a shell function from /usr/share/git/git-prompt.sh

Answer 4

@icarus's great solution works for functions, as long as they are defined literally and not the result of an eval of the contents of another file (in which the file with the eval will show up as the source). It will not print the source file of aliases, shell built-ins (like echo) and executables (binary or not), and I believe this information is not available in general. Some commands might print their source files (and may even be truthful about it), either in the course of normal execution or in response to a signal.

__git_ps1 is defined in /usr/share/git/git-prompt.sh and /usr/share/git/completion/git-prompt.sh on my system, Arch Linux, so it may be the same for you.

Have a look at the Invocation section of man bash if you want look for commands specifically sourced at the start of the shell - they may source other files which in turn source other files.

Answer 5

Declare a function with the same name and set it readonly as early as possible, then activate xtrace mode, something like:

__git_ps1(){ :;}
readonly -f __git_ps1
set -x

After that when you log in you will see trace information that includes sourcing of files. In the moment there is an attempt for a declaration of the existing readonly function, you will see an error message. The last sourced file before it should contain the declaration you look for.

You may need to put this in the system bash profile. Also remember to revert the changes after finding the culprit.

Answer 6

Did you try this?

grep -rnw '/path/to/somewhere/' -e "pattern" 

or any of the other commands found here:

How do I find all files containing specific text on Linux? | Stack Overflow

It seems that I need to give you more of an explanation. Your question asks "" Thus if you run the following command, it should return all files where a bash function is defined.

grep -rnw 'Path2Search' -e "#!/bin/bash"

BASH Programming - Functions | Linux Documentation Project