UNIX for Intermediate Users
Developed by:
User Liaison Section, D-7131
[Name and numbers removed at author's request]
Revision Date:
TABLE OF CONTENTS
I. INTRODUCTION........................................................................ ii
A. Audience..................................................................... ii
B. Course Objectives............................................................ ii
C. Course Handout Conventions...................................................iii
1. THE FILE CALLED .profile AND PROCESSES.............................................. 1
1.1 HOME........................................................................ 1
1.2 PATH........................................................................ 2
1.3 INGRES Environment Variables................................................ 2
1.4 ING_HOME.................................................................... 3
1.5 TERM_INGRES................................................................. 3
1.6 ING_EDIT.................................................................... 3
1.7 Processes................................................................... 4
1.8 Executing a Command......................................................... 4
1.9 Process Identification...................................................... 5
1.10 Interrupt Handling......................................................... 7
2. COMPILING "C" PROGRAMS............................................................... 10
2.1 "C": Sample Program with a Main and Two Functions
in One ............................................................ 10
2.2 "C": Compiling a Program.................................................... 12
2.3 "C": Renaming the Executable Module......................................... 13
2.4 "C": Giving a Name to the Output File....................................... 14
2.5 "C": Producing an Assembly Listing.......................................... 15
2.6 "C": Main and Two Functions in Three Separate
Source Files.............................................................. 16
2.7 "C": Compiling but Not Producing an Executable
Module.................................................................... 17
3. COMPILING FORTRAN PROGRAMS......................................................... 18
3.1 FORTRAN: Sample Program a Main and Two
Subroutines............................................................... 18
3.2 FORTRAN: Compiling a Program................................................ 19
3.3 FORTRAN: Renaming the Executable Module..................................... 20
3.4 FORTRAN: Giving a Name to the Output File................................... 21
3.5 FORTRAN: Producing an Assembly Listing...................................... 22
3.6 FORTRAN: Main and Two Subroutines in Three
Separate Source Files........................................ 23
3.7 FORTRAN: Compiling But Not Producing an Executable
Module.................................................................... 24
3.8 FORTRAN: Compiling Object Files to Produce an
Executable Module....................................... 25
4. COMPILING COBOL PROGRAMS............................................................ 26
4.1 COBOL: Sample Program with a Main and Two
Subroutines............................................................... 26
4.2 COBOL: Compiling a Program.................................................. 27
4.3 COBOL: Running a Program.................................................... 28
Workshop 2-4..................................................................... 30
5. UNIX TOOLS.......................................................................... 34
5.1 The make Utility............................................................ 34
p: A Pattern Matching Filter............................................................ 37
5.2.1 More on Regular Expressions........................................ 38
5.2.2 Closure............................................................ 42
5.2.3 Some Nice grep Options ................................ 43
5.2.4 Summary of Regular Expression Characters........................... 44
5.3 sed: Edit a File to Standard Output......................................... 45
5.4 awk: A Pattern Matching Programming Language................................ 49
5.5 sort: Sort a File........................................................... 53
5.6 Archiver and Library Maintainer............................................. 56
5.7 Creating an Archive File with Object Modules................................ 57
5.8 Verifying the Contents of the Archive File.................................. 57
5.9 Removing Duplicate Object Files............................................. 58
5.10 Compiling Main and Archive Files........................................... 58
Workshop 5....................................................................... 59
6. UNIX UTILITIES PART I - DISPLAY AND MANIPULATE FILES................................ 63
7. UNIX UTILITIES PART II - DISPLAY AND ALTER STAUTS................................... 73
8. UNIX UTILITIES PART III - MISCELLANEOUS............................................. 85
9. ADVANCED FEATURES OF FTP............................................................ 90
9.1 Initializing FTP on UMAX.................................................... 91
9.2 Multiple File Transfers..................................................... 92
9.3 Auto Login Feature.......................................................... 93
9.4 Macros...................................................................... 95
9.5 Filename Translation........................................................ 96
9.6 Aborting Transfers.......................................................... 97
9.7 More Remote Computer Commands............................................... 98
Workshop 10...................................................................... 99
APPENDIX A - sh.........................................................................101
APPENDIX B - ftp........................................................................116
APPENDIX C - C Compiler.................................................................128
APPENDIX D - FORTRAN Compiler...........................................................137
APPENDIX E - lint.......................................................................147
APPENDIX F - cb.........................................................................151
APPENDIX G - ar.........................................................................152
INDEX...................................................................................157
I. INTRODUCTION
A. Audience
This course is for individuals who need to use utilities and
advanced features of the UNIX operating system.
B. Course Objectives
Upon successful completion of this course the student will be
able to:
1. Compile C, FORTRAN, and COBOL programs.
2. Create processes to run in the background
3. Use advanced features of FTP such as: multiple file
transfers, auto logins, macros, globbing, filename
translation, aborting transfers, and other remote
computer commands.
4. Use UNIX utility programs such as grep, sed, awk, sort,
and others.
5. Use the make utility.
6. Understand processes, including structure, executing a
command, process identification, exit status, plus .
(dot) and exec processing.
C. Course Handout Conventions
There are several conventions used in this handout for
consistency and easier interpretation:
1. Samples of actual terminal sessions are single-lined
boxed.
2. User entries are shown in bold print and are
underlined.
exit
3. All keyboard functions in the text will be bold.
(Ret) Backspace
Tab Ctrl-F6
Print (Shift-F7) Go to DOS (1)
NOTE: (Ret) indicates the Return or Enter key
located above the right Shift key.
4. Examples of user entries not showing the computer's
response are in dotted-lined boxes.
5. Command formats are double-lined boxed.
6. Three dots either in vertical or horizontal alignment
mean continuation or that data is missing from diagram.
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� �
� Multimax, Nanobus, and UMAX are trademarks of �
� Encore Computer Corporation. �
� �
� �
� Annex is a trademark of XYLOGICS, Inc. �
� �
� �
� UNIX and Teletype are registered trademarks of �
� AT&T Bell Laboratories �
� �
� �
� Ethernet is a trademark of Xerox Corporation �
� �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
1. UNIX PROCESSES AND A FILE CALLED .profile
1.1 Processes
A process is the execution of a command by UNIX. Processes can
also be executed by the operating system itself. Like the file
structure, the process structure is hierarchical. It contains
parents, children, and even a root. A parent can fork (or spawn)
a child process. That child can, in turn, fork other processes.
The first thing the operating system does to begin execution is
to create a single process, PID number 1. PID stands for Process
Identification. This process will hold the same position as the
root directory in the file structure. This process is the
ancestor to all processes that each user works with. It forks a
process for each terminal. Each one of these processes becomes a
Shell process when the user logs in.
1.2 Process Identification
The UNIX operating system assigns a unique process identification
number (PID) to each process. It will keep the same PID as long
as the process is in existence. During one session, the same
process is always executing the login Shell. When you execute
another command, a new process is forked and a new PID is
assigned to that process. When that child process is finished,
you are returned to the login process, which is running the
Shell, and that parent process has the same PID as when you
logged in.
The Shell stores the PID in Shell variable called $$. The PID
can also be shown with the process status (ps) command. The
format for ps is as follows:
�袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴敲
� Command Format: ps [options] �
� �
� See on-line manual for options �
훤袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴�
With no options given the ps command will give you certain
information about processes associated with the controlling
terminal. The output consists of a short listing containing the
process id, terminal id, cumulative execution time, and the
command name. Otherwise, options will control the display.
Sample session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴커
� $echo $$ �
� 8347 �
� $ps �
� PID TTY TIME COMMAND �
� 8347 rt021a0 0:03 ksh �
� 8376 rt021a0 0:06 ps �
� $ �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴켸
The PID numbers of the Shell are the same in the sample session
because the Shell will substitute its own PID number for $$.
The Shell makes the substitution before it forks a new process to
execute the echo command. Therefore, echo will display the PID
number of the process that called it, not the PID of the process
that is executing it.
The -l option will display more information about the processes.
Sample Session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴커
� $ps -l �
� F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME COMD �
� f0000 S 115 8347 309 2 30 20 1009000 140 94014 rt021a0 0:03 ksh �
� f0000 O 115 8386 8347 16 68 20 1308000 72 rt021a0 0:01 ps �
� $ps -l �
� F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME COMD �
� f0000 S 115 8347 309 1 30 20 1009000 140 94014 rt021a0 0:03 ksh �
� f0000 O 115 8387 8347 26 73 20 1146000 72 rt021a0 0:01 ps �
� $ �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴켸
1.3 Executing a Command
When you give a command to the Shell, it will fork a process to
execute the command. While the child process is executing the
command, the parent will go to sleep. Sleeping means that the
process will not use any CPU time. It remains inactive until it
is awakened. When the child process has finished executing the
command, it dies. The parent process, which is running the
Shell, wakes up and prompts you for another command.
When you request a process to run in the background (by ending
the command line with an ampersand character (&), the Shell forks
a child process that is allowed to run to completion. The parent
process will report the PID of the child process and then prompt
you for another command. The child and parent are now
independent processes.
1.4 The . (dot) and exec Commands
There are two ways to execute a program without forking a new
process. The . (dot) command will execute the script as part of
the current process. When the new script has finished executing,
the current process will continue to execute the original script.
The exec command will execute the new script in place of
(overlays) the original script and never returns to the original
script.
The . (dot) command will not execute compiled files (binary) and it does not require execute
permission on the script file that is being executed. The exec command does require access
permission to either a binary program or a shell script.
Sample session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� $ls -l prog2 �
� -rw-r--r-- 1 teacher class 22 Jan 18 10:30 prog2 �
� $cat prog2 �
� echo 'prog2 PID =' $$ �
� $cat dot_example �
� echo $0 'PID=' $$ �
� . prog2 �
� echo 'This line is executed' �
� $dot_example �
� dot_example PID= 6942 �
� prog2 PID = 6942 �
� This line is executed �
� $ �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
The exec command will overlay the sh and control will never return to the calling script.
Let's look at another example with a call to prog2 using exec instead of . (dot):
Sample session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� $ls -l prog2 �
� -rwxr-xr-x 1 teacher class 22 Jan 18 10:30 prog2 �
� $cat prog2 �
� echo 'prog2 PID =' $$ �
� $cat exec_example �
� echo $0 'PID=' $$ �
� exec prog2 �
� echo 'This line is never executed' �
� $exec_example �
� exec_example PID= 6950 �
� prog2 PID = 6950 �
� $ �
� �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
Background Processing
When a program is running in background you do not have to wait for it to finish before
starting another program. This is useful because you can start long/large jobs and then
continue to do another task on your terminal.
To run a program in background simply type an ampersand character (&) at the end of the
command line before the (Ret) key. The Shell will return the PID of the background process
and then give you another system prompt.
Sample session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� $ls -l | lp & �
� [1] 21334 �
� $request id is mt_600-2736 (standard input) �
� �
� $ �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
If the background task sends output to standard output and you fail to redirect it, the
output will appear on your terminal even if you are running another program at the time.
It is necessary to use the kill command to stop a process that is running in background the
(DEL) key or its equivalent will not work.
Exit Status
When a process stops executing for any reason, it will return an exit status to the parent
process. This exit status is also referred to as a condition code or return code.The Shell
stores the exit status in a Shell variable called $?. By convention, a non-zero exit status
means that it has a false value and the command failed. On the other hand, a zero status
indicates true and the command was successful.
It is possible for you to specify the exit status when you exit a script. This is done by
specifying the number to be used as the exit status using the exit command. The following
script is an example:
Sample Session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� $cat exit_example �
� echo 'This program returns an exit status' �
� echo 'of 7.' �
� exit 7 �
� $exit_example �
� This program returns an exit status �
� of 7. �
� $echo $? �
� 7 �
� $echo $? �
� 0 �
� $ �
� �
읕컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
This script will display the message and then exit with an exit code of 7. The exit status
is stored in the Shell variable called $?. The second echo command above displays the exit
status of the first echo command. Since it completed successfully it has a value of zero.
1.4 Interrupt Handling
A signal is a report to a process about a condition. UNIX uses
these signals to report bad system calls, broken pipes, illegal
instructions, and other conditions. There are three signals that
are useful when programming in the Shell. They are the terminal
interrupt signal (number 2), the kill signal (number 9) and the
software termination signal (number 15).
You can use the trap command to capture a signal and then take
whatever action you specify. It can close files or finish other
processing that needs to be done, display a message, terminate
execution immediately, or ignore the signal.
�袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴敲
� Command Format: trap ['commands'] signal_numbers �
� �
� See online man pages for details �
� �
훤袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴袴�
The signal_numbers are the numbers corresponding to the signals
that will be trapped by the trap command. There must be at least
one number present. The 'commands' portion of the command is
optional. If it is not present, the command resets the trap to
its initial condition, which is to exit the program. When the
commands is present the Shell executes the commands when it
catches one of the signals. After executing the commands, the
Shell continues executing the script where it left off.
You can interrupt a program you are running in the foreground by
pressing the Delete key. When you press this key a signal
(number 2), a terminal interrupt, to the program. The Shell will
terminate the execution of the program if the program does not
trap the signal. The following example demonstrates the trap
command that will trap the signal and return an exit status of 1.
Sample session:
旼컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴�
� $cat inter �
� trap 'echo PROGRAM INTERRUPTED; exit 1' 2 �
� while (true) �
� do
TUCoPS is optimized to look best in Firefox® on a widescreen monitor (1440x900 or better).
Site design & layout copyright © 1986-2024 AOH
