Oct 24

Shells, terminals, and such

The tty command gives the logical name (file name) of the terminal that you are on. Open up two shells, type tty in each of them and see that the results are different.
Since the terminals are represented by logical file names, you can cat to these files, such as:
```
cat filename > /dev/<your terminal device name here>
```
which basically dumps the contents of filename onto the screen (terminal) of your choice.
Recall how to determine the shell you are running in your terminal with the ps command. There are two main classes of shells: C-shell based (csh, tcsh) and sh-based (sh, bash, ksh). In class we will cover bash since that is the default login shell for your lab machines.

Basic Bash

From now on, it is assumed that you are in a Bash shell. If not, just type bash to begin and enter a Bash shell. Bash uses several pre-defined variables to go about its job. Do a set to see what variables have been defined.
You can print out values of variables using the echo command that you know already. e.g.,
```
echo $LINES
echo $COLUMNS
echo $USERNAME
echo $PS1
```
The last echo command above prints the format for the prompt. To interpret the funny characters, do a man bash and search for the string "prompt". Searching is done by first typing "/" and then the search string. Press "n" to do a "find next". You can change variables by, e.g.,
```
PS1='[\u]\$'
```
This will make the prompt to comprise of just the username enclosed in square brackets and followed by a $ symbol. Similarly, you can customize the prompt to whatever you desire.
Note that we say echo $PS1 but not echo PS1. Similarly, we do: PS1= and not $PS1=. Just PS1 refers to the variable. $PS1 refers to the value of that variable. In the first case you want to echo the value of the variable. In the second case, you want to assign a value to the name of the variable, so you use the name literally.
You are not restricted to the use of the above variables. You can define your own variables and use them, e.g.,
```
INSTRUCTOR=Naren\ Ramakrishnan
echo $INSTRUCTOR
```

Subshells

You can enter one bash shell from another by typing bash again.
Let us suppose you set the variable INSTRUCTOR before entering the new shell. Inside the new shell, typing echo $INSTRUCTOR reveals that the variable has mysteriously gone! It appears that variables defined in one shell are not automatically carried over to the subshells!
To ensure that variables are carried over, type
```
export INSTRUCTOR
```
from the original (i.e., parent) shell. Now, inside the child shell, note that the variable is appropriately defined.

Simple bash scripts

Prefix every shell script with the line

#!/bin/bash

The "#!" tells Linux that whatever follows is to be interpeted/executed using the /bin/bash command (i.e., the bash shell). Put your shell script in a file, say myscript.sh, and make the script executable by doing chmod u+x myscript.sh. To execute the script, just type its name as a command. However, just typing myscript.sh at the command prompt might not work. You would need to do ./myscript.sh, to indicate the path (i.e., the current directory) location of the script. If you would like the shell to find the path automatically, you must suitably set the PATH environment variable. For instance, let us suppose this script is in a directory called /home/jimmy/cs2204. You do:

PATH=$PATH:/home/jimmy/cs2204

in essence, appending "/home/jimmy/cs2204" to the current value of PATH and making the result to be the new value of PATH. From this point onwards, you can get away with just typing myscript.sh.

Here's the mandatory first bash script:
```
#!/bin/bash
echo "Hello World"
```

This one prints numbers from 1 to 4:

#!/bin/bash
for i in 1 2 3 4
do
  echo $i
done

If we omit the stuff including and after the "in" in a for loop, bash takes it to mean that we want the loop index to range over the command line arguments (given when the command is invoked). For instance,
```
#!/bin/bash
for ut
do
   mv $ut `echo $ut | tr "[a-z]" "[A-Z]"`
done
```
Here, ut is a variable that ranges over the arguments. Lets put this shell script in a file called toupper and invoke toupper as: toupper home.accounts office.accounts. Then, the loop variable ut essentially first takes the value home.accounts, then takes the value office.accounts. The above shell script renames each file given as argument by replacing every lowecase letter with an upper case letter.

An important point to note in the above command is the backquote (`). This is a cue to bash to execute the command enclosed within the backquotes and return the result. Without the backquotes, the above command will not produce the desired effect.

You can even run the shell script on itself!; like so:
```
toupper toupper
```
From this point, you will have to refer to the script as TOUPPER.

The read command reads input from the terminal. Try the following shell script

#!/bin/bash
echo "Please type your name"
read name
echo "Hi $name, lets be friends!"

Some cool stuff

You can borrow the ideas so far to create some rather cool and eerie scripts. For instance, here is a one-line script that deletes itself! Call it self-terminate:
```
#!/bin/rm
```
Notice that this script specifies its interpreter to be the UNIX rm command. For any script, all command line arguments are by default given as input. If there are no lines in the shell script beyond the first line, the intended action is simply to apply the first line on the command line arguments. In the above case, the only command line argument is the script itself, i.e., self-terminate. So, running the script is the equivalent of doing rm self-terminate!
Similarly, we can write a script that prints itself! (Try it as an exercise)