While following android eclipse debug tutorial, I encounter following commands.
cd /path/to/android/root
. build/envsetup.sh
lunch 1
make
emulator
My problem is what the dot before build/envsetup.sh
means?
Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. It only takes a minute to sign up.
Sign up to join this communityA dot in that context means to "source" the contents of that file into the current shell. With source
itself being a shell builtin command. And source
and the dot operator being synonyms.
Say I had the following contents in a sample.sh
file.
$ cat sample.sh
echo "hi"
echo "bye?"
Now when I source it:
$ . sample.sh
hi
bye?
$
Files such as this are often used to incorporate setup commands such as adding things to ones environment variables.
Say I had these commands in another file, addvars.sh
.
$ cat addvars.sh
export VAR1="some var1 string"
export VAR2="some var2 string"
Notice that I don't have any variables in my current shell's environment.
$ env | grep VAR
$
Now when I source this file:
$ . addvars.sh
$
OK, doesn't seem like it did anything, but when we check the env
variables again:
$ env | grep VAR
VAR1=some var1 string
VAR2=some var2 string
To add to slm's answer:
There are two ways to run a shell script. One is to run the script in a separate process, which means anything about the shell's environment (memory state) will revert to the state of the "parent" shell before running the "child" shell process.
For example, the current working directory (the location in the filesystem one is in) is determined on a per-process basis. So, let's have a script that looks like this:
#!/bin/bash
cd ~
cd ..
pwd
So, let's call this script, oh, foo
. And let's run this script as follows: ./foo
We will see the following:
/home
(Standard disclaimer that there are a large number of Linux and other UNIX clone distributions out there, some of which do not put user's directories in /home
. Or, as we used to say "Your mileage may vary")
Now, after running this script, let's type in this command
pwd
To see which directory we are in. We will see something like this:
/home/username
The reason being, again, the shell script we ran had its own environment (including its own directory where commands were being run), and that environment went away once the script finished running.
Now, let's run the foo
script like this
. ./foo
Or, equivalently:
source ./foo
If we do a pwd
afterwards, we will see this:
/home
The reason being: Sourcing a script doesn't call a separate process. It is like typing all of the commands in the parent process by hand; its environment is preserved after the script ends.
Let me come up with a simpler example. Let's have a script that looks like this:
#!/bin/bash
exit
Let's name it foo
. Let's make sure we can run it: chmod 755 foo
. Then, let's run it like this:
./foo
Nothing happens. However, on the other hand, if we do this:
. ./foo
Or this:
source ./foo
We log out.
The period (dot) is short hand for the bash built in source
. It will read and execute commands from a file in the current environment and return the exit status of the last command executed. The files can be in the current directory or anywhere in the PATH
. It does not need to be executable.
TL;DR
The dot is the same as the source command.
source is a Unix command that evaluates the file following the command, as a list of commands, executed in the current context.
Extracted from https://en.wikipedia.org/wiki/Source_(command)
. (source or dot operator)
Read and execute commands from the filename argument in the current shell context.
Syntax
. filename [arguments]
source filename [arguments]
source is a synonym for dot/period '.' in bash, but not in POSIX sh, so for maximum compatibility use the period.
When a script is run using source it runs within the existing shell, any variables created or modified by the script will remain available after the script completes. In contrast if the script is run just as filename, then a separate subshell (with a completely separate set of variables) would be spawned to run the script.
There is a subtle difference between executing a script by running .ss64script (dot ss64script) and . ss64script (dot space ss64script)
the first is running a file thats been hidden from the 'ls' command, (although ls -a will show hidden files) the second option will execute ss64script even if it has not been set as an executable with chmod.
# type .
. is a shell builtin
# help .
.: . filename [arguments]
Execute commands from a file in the current shell.
Read and execute commands from FILENAME in the current shell. The
entries in $PATH are used to find the directory containing FILENAME.
If any ARGUMENTS are supplied, they become the positional parameters
when FILENAME is executed.
Exit Status:
Returns the status of the last command executed in FILENAME; fails if
FILENAME cannot be read.
I think there is a comma missing in the manual. It should say “Execute commands from a file, in the current shell.”