Introduction to csh

This material is how things are done in tcsh. Other shells (zsh, bash, etc.) have the same capabilities but the syntax and commands might be different. Google is your friend!
• What is a shell?
  • A "shell" is a program that allows a user to interact with a computer's services.
  • A shell is traditionally run in a terminal window, and interaction is by a text-based command-line interface (CLI).
  • A graphical shell (GUI), e.g., Mac's Finder, Linux Gnome, provides a pointy-clicky cover over the CLI, and often offers less direct access to the computer's sevices.
  • In a UNIX CLI the user provides commands to get things done.
  • Two types of commands can be entered at a shell prompt: builtin commands, and names of executable files.
    • which tells if a command is builtin to the shell or an executable
      
    • builtins lists all the builtin commands

• Commonly used commands
  • ls - list the contents of a directory (the default is the current working directory)
  • echo - write to the screen
  • cd - change the current working directory (the default is the home directory)
  • cat - list the contents of a file
  • more and less - list the contents of a file one screen at a time
  • exit - exit the shell

• Shell startup
  • After a user logs into a UNIX system, the shell program specified in their password entry is run, and it is the shell that provides the prompt.
    • A shell may be run in other contexts, e.g., in a shell script or as a program like any other.
    • chsh and ypchsh change your shell (to a good one :-)
      
  • A tcsh login shell
    • Begins by executing commands from the system file, e.g., /etc/csh.cshrc
    • It then executes commands from files in the user's home directory, e.g., ~/.tcshrc or ~/.cshrc
    • Then the system login file, e.g., /etc/csh.login
    • Then the user's ~/.login
  • Non-login shells read only /etc/csh.cshrc and ~/.tcshrc or ~/.cshrc on startup.
  • Sample configuration files for tcsh
    • .tcshrc
    • .login

• Special shell characters
  • Many characters have special meaning in most shells, including space $ ( ) [ ] * & | < > ; \ ` ' "
  • Command arguments may be enclosed in 'single quotes' or in "double quotes" to create a single argument with spaces in it. Example: File names with spaces
  • Backslash \ can be used to suppress the special meaning of individual characters, e.g., \' is a quote, \\ is a backslash. Example: Filenames with $s in them

• Shell variables
  • The shell maintains a list of variables, each of which has as value a list of zero or more words. The values of shell variables can be set with the set command and cleared with the unset command.
  • Values of variables are accessed by adding a $ prefix (same for environment variables)
  • Variables are also like arrays
    • Use ()s to set a variable to a list of space-separated values
    • $#variable - number of words in variable,
    • $variable[index] - the indexth word from the variable, counting from 1.
  • There are some special variables
    • $? - status from last command
    • $$ - the shell's process ID
    • $< - a word read from stdin (the keyboard by default, but more about this later)
    • $argv - command line arguments to the shell (useful for scripts - see below).
  • The shell synchronizes afsuser, group, home, path, shlvl, term and user with the environment variables of the same names. Whenever the environment variable changes the shell changes the corresponding shell variable to match (unless the shell variable is read-only) and vice versa.

• Aliases
  • These tell the shell to replace input commands.
  • Typically defined in the user's shell resource file

    alias   ls      ls -F
    alias   h       history
    alias   vi      vim
    alias   ispell      'ispell -t -d english -B -S\!*' 

  • Use the alias and unalias commands to set, examine, and clear aliases.

• Globbing
  • Describe to the shell (not OS) sets of file names with patterns
  • ~ means the home directory
  • ? means any character
    * means any string (including empty)
  • [<letters>] means any one of the <letters> (except ...), which can also be a range
    
  • ^ negates some glob expressions

• Commands
  • For each command entered, the shell:
    • Does alias substitution on the first word.
    • Does variable substitution on all words not in 'quotes' (they are done in "double quotes").
    • Does globbing all words not in 'quotes' or "double quotes".
    • Checks to see if it is builtin, and if so executes it.
    • If not builtin, starts a child process, and ...
      • Checks if it is an absolute file name, and if so executes it, else ...
      • For each member of the path variable, checks to see if the command is in that directory, and if so executes it.
        Hint: Add . as the first element of your path to execute files in the current working directory. Do it in your shell rc file.
  • `` can be used to run a command within a command; this is done after variable substitution. for example, wc `grep -l int *`

• Input/output
  • Every process starts with a standard input (stdin), standard output (stdout), and standard error (stderr) stream, each connected to some device.
  • The standard stream of a command may be redirected.
  • > name - The file name is used as standard output
    • >! name - Forces overwriting of an existing file
    • >& name - Includes stderr output
    • >&! name - Combination
  • >> name - Like >, but appends output to the end of name.
  • < name - Open file name as the standard input. (Example, AddIntsSTDIN)
  • << word - Read the shell input up to a line which is identical to word.
  • A series of commands joined by | characters forms a pipeline. The stdout of the command in a pipeline is connected to the stdin of the next.
    • stderr output may be directed through a pipe with the stdout using |&
  • The shell cannot presently redirect stderr without also redirecting stdout, but

    (command > output-file)  >&  error-file 

    is often an acceptable workaround.

• The Idea of Scripts
  • A shell script is a sequence of shell commands
  • Lines starting with # are comments
  • $N is argument N to the script (shorthand for $argv[N])
  • Two ways to run scripts
    • source <script file>
    • Add a line that specifies which shell should be used to execute the commands on its first line, with a leading #!, e.g., #!/bin/tcsh. Make the file executable (with chmod +x your_file_name).
  • LookingForInts - Sample tcsh script
  • Redirection - Scripts that uses some redirection of IO

Exercises

• What command is used to change your shell on
  1. A standalone UNIX system?
  2. An NIS served UNIX system?
• How can you find what code is executed for a given user command?
• How many builtin commands are there in your shell?
• What does the source command do?
• Write a command that send the contents of the file MyInputData into the program FirstAnalysis, whose output is then piped to the input of the program SecondAnalysis, whose output and error messages are appended to the file AnalysisResults.

Exam Style Questions

• What two files in your home directory are read by your shell when you login?
• Give the command to set a shell variable named NewPath to the current value of the path variable.
• List in order the places that a shell checks for the code to execute a user's command.
• Explain how to make a shell script into a standalone executable.
• Explain the effect of putting the following lines in your .tcshrc file:

  alias vi vim
  alias pico vi 

• Explain the underlying mechanism that causes a command such as

  ls -la | grep System 

  to send the output from ls to the input of grep.
• Explain the difference between placing a string in single and double quotes in a command.