These scripts, while not fitting into the text of this document, do illustrate some interesting shell programming techniques. They are useful, too. Have fun analyzing and running them.
Example A-1. manview: Viewing formatted manpages
1 #!/bin/bash 2 # manview.sh: Formats the source of a man page for viewing. 3 4 # This is useful when writing man page source and you want to 5 #+ look at the intermediate results on the fly while working on it. 6 7 E_WRONGARGS=65 8 9 if [ -z "$1" ] 10 then 11 echo "Usage: `basename $0` filename" 12 exit $E_WRONGARGS 13 fi 14 15 groff -Tascii -man $1 | less 16 # From the man page for groff. 17 18 # If the man page includes tables and/or equations, 19 #+ then the above code will barf. 20 # The following line can handle such cases. 21 # 22 # gtbl < "$1" | geqn -Tlatin1 | groff -Tlatin1 -mtty-char -man 23 # 24 # Thanks, S.C. 25 26 exit 0 |
Example A-2. mailformat: Formatting an e-mail message
1 #!/bin/bash 2 # mail-format.sh: Format e-mail messages. 3 4 # Gets rid of carets, tabs, also fold excessively long lines. 5 6 # ================================================================= 7 # Standard Check for Script Argument(s) 8 ARGS=1 9 E_BADARGS=65 10 E_NOFILE=66 11 12 if [ $# -ne $ARGS ] # Correct number of arguments passed to script? 13 then 14 echo "Usage: `basename $0` filename" 15 exit $E_BADARGS 16 fi 17 18 if [ -f "$1" ] # Check if file exists. 19 then 20 file_name=$1 21 else 22 echo "File \"$1\" does not exist." 23 exit $E_NOFILE 24 fi 25 # ================================================================= 26 27 MAXWIDTH=70 # Width to fold long lines to. 28 29 # Delete carets and tabs at beginning of lines, 30 #+ then fold lines to $MAXWIDTH characters. 31 sed ' 32 s/^>// 33 s/^ *>// 34 s/^ *// 35 s/ *// 36 ' $1 | fold -s --width=$MAXWIDTH 37 # -s option to "fold" breaks lines at whitespace, if possible. 38 39 # This script was inspired by an article in a well-known trade journal 40 #+ extolling a 164K Windows utility with similar functionality. 41 # 42 # An nice set of text processing utilities and an efficient 43 #+ scripting language provide an alternative to bloated executables. 44 45 exit 0 |
Example A-3. rn: A simple-minded file rename utility
This script is a modification of Example 12-15.
1 #! /bin/bash 2 # 3 # Very simpleminded filename "rename" utility (based on "lowercase.sh"). 4 # 5 # The "ren" utility, by Vladimir Lanin (lanin@csd2.nyu.edu), 6 #+ does a much better job of this. 7 8 9 ARGS=2 10 E_BADARGS=65 11 ONE=1 # For getting singular/plural right (see below). 12 13 if [ $# -ne "$ARGS" ] 14 then 15 echo "Usage: `basename $0` old-pattern new-pattern" 16 # As in "rn gif jpg", which renames all gif files in working directory to jpg. 17 exit $E_BADARGS 18 fi 19 20 number=0 # Keeps track of how many files actually renamed. 21 22 23 for filename in *$1* #Traverse all matching files in directory. 24 do 25 if [ -f "$filename" ] # If finds match... 26 then 27 fname=`basename $filename` # Strip off path. 28 n=`echo $fname | sed -e "s/$1/$2/"` # Substitute new for old in filename. 29 mv $fname $n # Rename. 30 let "number += 1" 31 fi 32 done 33 34 if [ "$number" -eq "$ONE" ] # For correct grammar. 35 then 36 echo "$number file renamed." 37 else 38 echo "$number files renamed." 39 fi 40 41 exit 0 42 43 44 # Exercises: 45 # --------- 46 # What type of files will this not work on? 47 # How can this be fixed? 48 # 49 # Rewrite this script to process all the files in a directory 50 #+ containing spaces in their names, and to rename them, 51 #+ substituting an underscore for each space. |
Example A-4. blank-rename: renames filenames containing blanks
This is an even simpler-minded version of previous script.
1 #! /bin/bash 2 # blank-rename.sh 3 # 4 # Substitutes underscores for blanks in all the filenames in a directory. 5 6 ONE=1 # For getting singular/plural right (see below). 7 number=0 # Keeps track of how many files actually renamed. 8 FOUND=0 # Successful return value. 9 10 for filename in * #Traverse all files in directory. 11 do 12 echo "$filename" | grep -q " " # Check whether filename 13 if [ $? -eq $FOUND ] #+ contains space(s). 14 then 15 fname=$filename # Strip off path. 16 n=`echo $fname | sed -e "s/ /_/g"` # Substitute underscore for blank. 17 mv "$fname" "$n" # Do the actual renaming. 18 let "number += 1" 19 fi 20 done 21 22 if [ "$number" -eq "$ONE" ] # For correct grammar. 23 then 24 echo "$number file renamed." 25 else 26 echo "$number files renamed." 27 fi 28 29 exit 0 |
Example A-5. encryptedpw: Uploading to an ftp site, using a locally encrypted password
1 #!/bin/bash 2 3 # Example "ex72.sh" modified to use encrypted password. 4 5 # Note that this is still somewhat insecure, 6 #+ since the decrypted password is sent in the clear. 7 # Use something like "ssh" if this is a concern. 8 9 E_BADARGS=65 10 11 if [ -z "$1" ] 12 then 13 echo "Usage: `basename $0` filename" 14 exit $E_BADARGS 15 fi 16 17 Username=bozo # Change to suit. 18 pword=/home/bozo/secret/password_encrypted.file 19 # File containing encrypted password. 20 21 Filename=`basename $1` # Strips pathname out of file name 22 23 Server="XXX" 24 Directory="YYY" # Change above to actual server name & directory. 25 26 27 Password=`cruft <$pword` # Decrypt password. 28 # Uses the author's own "cruft" file encryption package, 29 #+ based on the classic "onetime pad" algorithm, 30 #+ and obtainable from: 31 #+ Primary-site: ftp://ibiblio.org/pub/Linux/utils/file 32 #+ cruft-0.2.tar.gz [16k] 33 34 35 ftp -n $Server <<End-Of-Session 36 user $Username $Password 37 binary 38 bell 39 cd $Directory 40 put $Filename 41 bye 42 End-Of-Session 43 # -n option to "ftp" disables auto-logon. 44 # "bell" rings 'bell' after each file transfer. 45 46 exit 0 |
Example A-6. copy-cd: Copying a data CD
1 #!/bin/bash 2 # copy-cd.sh: copying a data CD 3 4 CDROM=/dev/cdrom # CD ROM device 5 OF=/home/bozo/projects/cdimage.iso # output file 6 # /xxxx/xxxxxxx/ Change to suit your system. 7 BLOCKSIZE=2048 8 SPEED=2 # May use higher speed if supported. 9 10 echo; echo "Insert source CD, but do *not* mount it." 11 echo "Press ENTER when ready. " 12 read ready # Wait for input, $ready not used. 13 14 echo; echo "Copying the source CD to $OF." 15 echo "This may take a while. Please be patient." 16 17 dd if=$CDROM of=$OF bs=$BLOCKSIZE # Raw device copy. 18 19 20 echo; echo "Remove data CD." 21 echo "Insert blank CDR." 22 echo "Press ENTER when ready. " 23 read ready # Wait for input, $ready not used. 24 25 echo "Copying $OF to CDR." 26 27 cdrecord -v -isosize speed=$SPEED dev=0,0 $OF 28 # Uses Joerg Schilling's "cdrecord" package (see its docs). 29 # http://www.fokus.gmd.de/nthp/employees/schilling/cdrecord.html 30 31 32 echo; echo "Done copying $OF to CDR on device $CDROM." 33 34 echo "Do you want to erase the image file (y/n)? " # Probably a huge file. 35 read answer 36 37 case "$answer" in 38 [yY]) rm -f $OF 39 echo "$OF erased." 40 ;; 41 *) echo "$OF not erased.";; 42 esac 43 44 echo 45 46 # Exercise: 47 # Change the above "case" statement to also accept "yes" and "Yes" as input. 48 49 exit 0 |
Example A-7. Collatz series
1 #!/bin/bash
2 # collatz.sh
3
4 # The notorious "hailstone" or Collatz series.
5 # -------------------------------------------
6 # 1) Get the integer "seed" from the command line.
7 # 2) NUMBER <--- seed
8 # 3) Print NUMBER.
9 # 4) If NUMBER is even, divide by 2, or
10 # 5)+ if odd, multiply by 3 and add 1.
11 # 6) NUMBER <--- result
12 # 7) Loop back to step 3 (for specified number of iterations).
13 #
14 # The theory is that every sequence,
15 #+ no matter how large the initial value,
16 #+ eventually settles down to repeating "4,2,1..." cycles,
17 #+ even after fluctuating through a wide range of values.
18 #
19 # This is an instance of an "iterate",
20 #+ an operation that feeds its output back into the input.
21 # Sometimes the result is a "chaotic" series.
22
23
24 MAX_ITERATIONS=200
25 # For large seed numbers (>32000), increase MAX_ITERATIONS.
26
27 h=${1:-$$} # Seed
28 # Use $PID as seed,
29 #+ if not specified as command-line arg.
30
31 echo
32 echo "C($h) --- $MAX_ITERATIONS Iterations"
33 echo
34
35 for ((i=1; i<=MAX_ITERATIONS; i++))
36 do
37
38 echo -n "$h "
39 # ^^^^^
40 # tab
41
42 let "remainder = h % 2"
43 if [ "$remainder" -eq 0 ] # Even?
44 then
45 let "h /= 2" # Divide by 2.
46 else
47 let "h = h*3 + 1" # Multiply by 3 and add 1.
48 fi
49
50
51 COLUMNS=10 # Output 10 values per line.
52 let "line_break = i % $COLUMNS"
53 if [ "$line_break" -eq 0 ]
54 then
55 echo
56 fi
57
58 done
59
60 echo
61
62 # For more information on this mathematical function,
63 #+ see "Computers, Pattern, Chaos, and Beauty", by Pickover, p. 185 ff.,
64 #+ as listed in the bibliography.
65
66 exit 0 |
Example A-8. days-between: Calculate number of days between two dates
1 #!/bin/bash
2 # days-between.sh: Number of days between two dates.
3 # Usage: ./days-between.sh [M]M/[D]D/YYYY [M]M/[D]D/YYYY
4
5 ARGS=2 # Two command line parameters expected.
6 E_PARAM_ERR=65 # Param error.
7
8 REFYR=1600 # Reference year.
9 CENTURY=100
10 DIY=365
11 ADJ_DIY=367 # Adjusted for leap year + fraction.
12 MIY=12
13 DIM=31
14 LEAPCYCLE=4
15
16 MAXRETVAL=256 # Largest permissable
17 # positive return value from a function.
18
19 diff= # Declare global variable for date difference.
20 value= # Declare global variable for absolute value.
21 day= # Declare globals for day, month, year.
22 month=
23 year=
24
25
26 Param_Error () # Command line parameters wrong.
27 {
28 echo "Usage: `basename $0` [M]M/[D]D/YYYY [M]M/[D]D/YYYY"
29 echo " (date must be after 1/3/1600)"
30 exit $E_PARAM_ERR
31 }
32
33
34 Parse_Date () # Parse date from command line params.
35 {
36 month=${1%%/**}
37 dm=${1%/**} # Day and month.
38 day=${dm#*/}
39 let "year = `basename $1`" # Not a filename, but works just the same.
40 }
41
42
43 check_date () # Checks for invalid date(s) passed.
44 {
45 [ "$day" -gt "$DIM" ] || [ "$month" -gt "$MIY" ] || [ "$year" -lt "$REFYR" ] && Param_Error
46 # Exit script on bad value(s).
47 # Uses "or-list / and-list".
48 #
49 # Exercise: Implement more rigorous date checking.
50 }
51
52
53 strip_leading_zero () # Better to strip possible leading zero(s)
54 { # from day and/or month
55 val=${1#0} # since otherwise Bash will interpret them
56 return $val # as octal values (POSIX.2, sect 2.9.2.1).
57 }
58
59
60 day_index () # Gauss' Formula:
61 { # Days from Jan. 3, 1600 to date passed as param.
62
63 day=$1
64 month=$2
65 year=$3
66
67 let "month = $month - 2"
68 if [ "$month" -le 0 ]
69 then
70 let "month += 12"
71 let "year -= 1"
72 fi
73
74 let "year -= $REFYR"
75 let "indexyr = $year / $CENTURY"
76
77
78 let "Days = $DIY*$year + $year/$LEAPCYCLE - $indexyr + $indexyr/$LEAPCYCLE + $ADJ_DIY*$month/$MIY + $day - $DIM"
79 # For an in-depth explanation of this algorithm, see
80 # http://home.t-online.de/home/berndt.schwerdtfeger/cal.htm
81
82
83 if [ "$Days" -gt "$MAXRETVAL" ] # If greater than 256,
84 then # then change to negative value
85 let "dindex = 0 - $Days" # which can be returned from function.
86 else let "dindex = $Days"
87 fi
88
89 return $dindex
90
91 }
92
93
94 calculate_difference () # Difference between to day indices.
95 {
96 let "diff = $1 - $2" # Global variable.
97 }
98
99
100 abs () # Absolute value
101 { # Uses global "value" variable.
102 if [ "$1" -lt 0 ] # If negative
103 then # then
104 let "value = 0 - $1" # change sign,
105 else # else
106 let "value = $1" # leave it alone.
107 fi
108 }
109
110
111
112 if [ $# -ne "$ARGS" ] # Require two command line params.
113 then
114 Param_Error
115 fi
116
117 Parse_Date $1
118 check_date $day $month $year # See if valid date.
119
120 strip_leading_zero $day # Remove any leading zeroes
121 day=$? # on day and/or month.
122 strip_leading_zero $month
123 month=$?
124
125 day_index $day $month $year
126 date1=$?
127
128 abs $date1 # Make sure it's positive
129 date1=$value # by getting absolute value.
130
131 Parse_Date $2
132 check_date $day $month $year
133
134 strip_leading_zero $day
135 day=$?
136 strip_leading_zero $month
137 month=$?
138
139 day_index $day $month $year
140 date2=$?
141
142 abs $date2 # Make sure it's positive.
143 date2=$value
144
145 calculate_difference $date1 $date2
146
147 abs $diff # Make sure it's positive.
148 diff=$value
149
150 echo $diff
151
152 exit 0
153 # Compare this script with the implementation of Gauss' Formula in C at
154 # http://buschencrew.hypermart.net/software/datedif |
Example A-9. Make a "dictionary"
1 #!/bin/bash 2 # makedict.sh [make dictionary] 3 4 # Modification of /usr/sbin/mkdict script. 5 # Original script copyright 1993, by Alec Muffett. 6 # 7 # This modified script included in this document in a manner 8 #+ consistent with the "LICENSE" document of the "Crack" package 9 #+ that the original script is a part of. 10 11 # This script processes text files to produce a sorted list 12 #+ of words found in the files. 13 # This may be useful for compiling dictionaries 14 #+ and for lexicographic research. 15 16 17 E_BADARGS=65 18 19 if [ ! -r "$1" ] # Need at least one 20 then #+ valid file argument. 21 echo "Usage: $0 files-to-process" 22 exit $E_BADARGS 23 fi 24 25 26 # SORT="sort" # No longer necessary to define options 27 #+ to sort. Changed from original script. 28 29 cat $* | # Contents of specified files to stdout. 30 tr A-Z a-z | # Convert to lowercase. 31 tr ' ' '\012' | # New: change spaces to newlines. 32 # tr -cd '\012[a-z][0-9]' | # Get rid of everything non-alphanumeric 33 #+ (original script). 34 tr -c '\012a-z' '\012' | # Rather than deleting 35 #+ now change non-alpha to newlines. 36 sort | # $SORT options unnecessary now. 37 uniq | # Remove duplicates. 38 grep -v '^#' | # Delete lines beginning with a hashmark. 39 grep -v '^$' # Delete blank lines. 40 41 exit 0 |
Example A-10. Soundex conversion
1 #!/bin/bash
2 # soundex.sh: Calculate "soundex" code for names
3
4 # =======================================================
5 # Soundex script
6 # by
7 # Mendel Cooper
8 # thegrendel@theriver.com
9 # 23 January, 2002
10 #
11 # Placed in the Public Domain.
12 #
13 # A slightly different version of this script appeared in
14 #+ Ed Schaefer's July, 2002 "Shell Corner" column
15 #+ in "Unix Review" on-line,
16 #+ http://www.unixreview.com/documents/uni1026336632258/
17 # =======================================================
18
19
20 ARGCOUNT=1 # Need name as argument.
21 E_WRONGARGS=70
22
23 if [ $# -ne "$ARGCOUNT" ]
24 then
25 echo "Usage: `basename $0` name"
26 exit $E_WRONGARGS
27 fi
28
29
30 assign_value () # Assigns numerical value
31 { #+ to letters of name.
32
33 val1=bfpv # 'b,f,p,v' = 1
34 val2=cgjkqsxz # 'c,g,j,k,q,s,x,z' = 2
35 val3=dt # etc.
36 val4=l
37 val5=mn
38 val6=r
39
40 # Exceptionally clever use of 'tr' follows.
41 # Try to figure out what is going on here.
42
43 value=$( echo "$1" \
44 | tr -d wh \
45 | tr $val1 1 | tr $val2 2 | tr $val3 3 \
46 | tr $val4 4 | tr $val5 5 | tr $val6 6 \
47 | tr -s 123456 \
48 | tr -d aeiouy )
49
50 # Assign letter values.
51 # Remove duplicate numbers, except when separated by vowels.
52 # Ignore vowels, except as separators, so delete them last.
53 # Ignore 'w' and 'h', even as separators, so delete them first.
54 #
55 # The above command substitution lays more pipe than a plumber <g>.
56
57 }
58
59
60 input_name="$1"
61 echo
62 echo "Name = $input_name"
63
64
65 # Change all characters of name input to lowercase.
66 # ------------------------------------------------
67 name=$( echo $input_name | tr A-Z a-z )
68 # ------------------------------------------------
69 # Just in case argument to script is mixed case.
70
71
72 # Prefix of soundex code: first letter of name.
73 # --------------------------------------------
74
75
76 char_pos=0 # Initialize character position.
77 prefix0=${name:$char_pos:1}
78 prefix=`echo $prefix0 | tr a-z A-Z`
79 # Uppercase 1st letter of soundex.
80
81 let "char_pos += 1" # Bump character position to 2nd letter of name.
82 name1=${name:$char_pos}
83
84
85 # ++++++++++++++++++++++++++ Exception Patch +++++++++++++++++++++++++++++++++
86 # Now, we run both the input name and the name shifted one char to the right
87 #+ through the value-assigning function.
88 # If we get the same value out, that means that the first two characters
89 #+ of the name have the same value assigned, and that one should cancel.
90 # However, we also need to test whether the first letter of the name
91 #+ is a vowel or 'w' or 'h', because otherwise this would bollix things up.
92
93 char1=`echo $prefix | tr A-Z a-z` # First letter of name, lowercased.
94
95 assign_value $name
96 s1=$value
97 assign_value $name1
98 s2=$value
99 assign_value $char1
100 s3=$value
101 s3=9$s3 # If first letter of name is a vowel
102 #+ or 'w' or 'h',
103 #+ then its "value" will be null (unset).
104 #+ Therefore, set it to 9, an otherwise
105 #+ unused value, which can be tested for.
106
107
108 if [[ "$s1" -ne "$s2" || "$s3" -eq 9 ]]
109 then
110 suffix=$s2
111 else
112 suffix=${s2:$char_pos}
113 fi
114 # ++++++++++++++++++++++ end Exception Patch +++++++++++++++++++++++++++++++++
115
116
117 padding=000 # Use at most 3 zeroes to pad.
118
119
120 soun=$prefix$suffix$padding # Pad with zeroes.
121
122 MAXLEN=4 # Truncate to maximum of 4 chars.
123 soundex=${soun:0:$MAXLEN}
124
125 echo "Soundex = $soundex"
126
127 echo
128
129 # The soundex code is a method of indexing and classifying names
130 #+ by grouping together the ones that sound alike.
131 # The soundex code for a given name is the first letter of the name,
132 #+ followed by a calculated three-number code.
133 # Similar sounding names should have almost the same soundex codes.
134
135 # Examples:
136 # Smith and Smythe both have a "S-530" soundex.
137 # Harrison = H-625
138 # Hargison = H-622
139 # Harriman = H-655
140
141 # This works out fairly well in practice, but there are numerous anomalies.
142 #
143 #
144 # The U.S. Census and certain other governmental agencies use soundex,
145 # as do genealogical researchers.
146 #
147 # For more information,
148 #+ see the "National Archives and Records Administration home page",
149 #+ http://www.nara.gov/genealogy/soundex/soundex.html
150
151
152
153 # Exercise:
154 # --------
155 # Simplify the "Exception Patch" section of this script.
156
157 exit 0 |
Example A-11. "Game of Life"
1 #!/bin/bash
2 # life.sh: "Life in the Slow Lane"
3
4 # ##################################################################### #
5 # This is the Bash script version of John Conway's "Game of Life". #
6 # "Life" is a simple implementation of cellular automata. #
7 # --------------------------------------------------------------------- #
8 # On a rectangular grid, let each "cell" be either "living" or "dead". #
9 # Designate a living cell with a dot, and a dead one with a blank space.#
10 # Begin with an arbitrarily drawn dot-and-blank grid, #
11 #+ and let this be the starting generation, "generation 0". #
12 # Determine each successive generation by the following rules: #
13 # 1) Each cell has 8 neighbors, the adjoining cells #
14 #+ left, right, top, bottom, and the 4 diagonals. #
15 # 123 #
16 # 4*5 #
17 # 678 #
18 # #
19 # 2) A living cell with either 2 or 3 living neighbors remains alive. #
20 # 3) A dead cell with 3 living neighbors becomes alive (a "birth"). #
21 SURVIVE=2 #
22 BIRTH=3 #
23 # 4) All other cases result in dead cells. #
24 # ##################################################################### #
25
26
27 startfile=gen0 # Read the starting generation from the file "gen0".
28 # Default, if no other file specified when invoking script.
29 #
30 if [ -n "$1" ] # Specify another "generation 0" file.
31 then
32 if [ -e "$1" ] # Check for existence.
33 then
34 startfile="$1"
35 fi
36 fi
37
38
39 ALIVE1=.
40 DEAD1=_
41 # Represent living and "dead" cells in the start-up file.
42
43 # This script uses a 10 x 10 grid (may be increased,
44 #+ but a large grid will will cause very slow execution).
45 ROWS=10
46 COLS=10
47
48 GENERATIONS=10 # How many generations to cycle through.
49 # Adjust this upwards,
50 #+ if you have time on your hands.
51
52 NONE_ALIVE=80 # Exit status on premature bailout,
53 #+ if no cells left alive.
54 TRUE=0
55 FALSE=1
56 ALIVE=0
57 DEAD=1
58
59 avar= # Global; holds current generation.
60 generation=0 # Initialize generation count.
61
62 # =================================================================
63
64
65 let "cells = $ROWS * $COLS"
66 # How many cells.
67
68 declare -a initial # Arrays containing "cells".
69 declare -a current
70
71 display ()
72 {
73
74 alive=0 # How many cells "alive".
75 # Initially zero.
76
77 declare -a arr
78 arr=( `echo "$1"` ) # Convert passed arg to array.
79
80 element_count=${#arr[*]}
81
82 local i
83 local rowcheck
84
85 for ((i=0; i<$element_count; i++))
86 do
87
88 # Insert newline at end of each row.
89 let "rowcheck = $i % ROWS"
90 if [ "$rowcheck" -eq 0 ]
91 then
92 echo # Newline.
93 echo -n " " # Indent.
94 fi
95
96 cell=${arr[i]}
97
98 if [ "$cell" = . ]
99 then
100 let "alive += 1"
101 fi
102
103 echo -n "$cell" | sed -e 's/_/ /g'
104 # Print out array and change underscores to spaces.
105 done
106
107 return
108
109 }
110
111 IsValid () # Test whether cell coordinate valid.
112 {
113
114 if [ -z "$1" -o -z "$2" ] # Mandatory arguments missing?
115 then
116 return $FALSE
117 fi
118
119 local row
120 local lower_limit=0 # Disallow negative coordinate.
121 local upper_limit
122 local left
123 local right
124
125 let "upper_limit = $ROWS * $COLS - 1" # Total number of cells.
126
127
128 if [ "$1" -lt "$lower_limit" -o "$1" -gt "$upper_limit" ]
129 then
130 return $FALSE # Out of array bounds.
131 fi
132
133 row=$2
134 let "left = $row * $ROWS" # Left limit.
135 let "right = $left + $COLS - 1" # Right limit.
136
137 if [ "$1" -lt "$left" -o "$1" -gt "$right" ]
138 then
139 return $FALSE # Beyond row boundary.
140 fi
141
142 return $TRUE # Valid coordinate.
143
144 }
145
146
147 IsAlive () # Test whether cell is alive.
148 # Takes array, cell number, state of cell as arguments.
149 {
150 GetCount "$1" $2 # Get alive cell count in neighborhood.
151 local nhbd=$?
152
153
154 if [ "$nhbd" -eq "$BIRTH" ] # Alive in any case.
155 then
156 return $ALIVE
157 fi
158
159 if [ "$3" = "." -a "$nhbd" -eq "$SURVIVE" ]
160 then # Alive only if previously alive.
161 return $ALIVE
162 fi
163
164 return $DEAD # Default.
165
166 }
167
168
169 GetCount () # Count live cells in passed cell's neighborhood.
170 # Two arguments needed:
171 # $1) variable holding array
172 # $2) cell number
173 {
174 local cell_number=$2
175 local array
176 local top
177 local center
178 local bottom
179 local r
180 local row
181 local i
182 local t_top
183 local t_cen
184 local t_bot
185 local count=0
186 local ROW_NHBD=3
187
188 array=( `echo "$1"` )
189
190 let "top = $cell_number - $COLS - 1" # Set up cell neighborhood.
191 let "center = $cell_number - 1"
192 let "bottom = $cell_number + $COLS - 1"
193 let "r = $cell_number / $ROWS"
194
195 for ((i=0; i<$ROW_NHBD; i++)) # Traverse from left to right.
196 do
197 let "t_top = $top + $i"
198 let "t_cen = $center + $i"
199 let "t_bot = $bottom + $i"
200
201
202 let "row = $r" # Count center row of neighborhood.
203 IsValid $t_cen $row # Valid cell position?
204 if [ $? -eq "$TRUE" ]
205 then
206 if [ ${array[$t_cen]} = "$ALIVE1" ] # Is it alive?
207 then # Yes?
208 let "count += 1" # Increment count.
209 fi
210 fi
211
212 let "row = $r - 1" # Count top row.
213 IsValid $t_top $row
214 if [ $? -eq "$TRUE" ]
215 then
216 if [ ${array[$t_top]} = "$ALIVE1" ]
217 then
218 let "count += 1"
219 fi
220 fi
221
222 let "row = $r + 1" # Count bottom row.
223 IsValid $t_bot $row
224 if [ $? -eq "$TRUE" ]
225 then
226 if [ ${array[$t_bot]} = "$ALIVE1" ]
227 then
228 let "count += 1"
229 fi
230 fi
231
232 done
233
234
235 if [ ${array[$cell_number]} = "$ALIVE1" ]
236 then
237 let "count -= 1" # Make sure value of tested cell itself
238 fi #+ is not counted.
239
240
241 return $count
242
243 }
244
245 next_gen () # Update generation array.
246 {
247
248 local array
249 local i=0
250
251 array=( `echo "$1"` ) # Convert passed arg to array.
252
253 while [ "$i" -lt "$cells" ]
254 do
255 IsAlive "$1" $i ${array[$i]} # Is cell alive?
256 if [ $? -eq "$ALIVE" ]
257 then # If alive, then
258 array[$i]=. #+ represent the cell as a period.
259 else
260 array[$i]="_" # Otherwise underscore
261 fi #+ (which will later be converted to space).
262 let "i += 1"
263 done
264
265
266 # let "generation += 1" # Increment generation count.
267
268 # Set variable to pass as parameter to "display" function.
269 avar=`echo ${array[@]}` # Convert array back to string variable.
270 display "$avar" # Display it.
271 echo; echo
272 echo "Generation $generation -- $alive alive"
273
274 if [ "$alive" -eq 0 ]
275 then
276 echo
277 echo "Premature exit: no more cells alive!"
278 exit $NONE_ALIVE # No point in continuing
279 fi #+ if no live cells.
280
281 }
282
283
284 # =========================================================
285
286 # main ()
287
288 # Load initial array with contents of startup file.
289 initial=( `cat "$startfile" | sed -e '/#/d' | tr -d '\n' |\
290 sed -e 's/\./\. /g' -e 's/_/_ /g'` )
291 # Delete lines containing '#' comment character.
292 # Remove linefeeds and insert space between elements.
293
294 clear # Clear screen.
295
296 echo # Title
297 echo "======================="
298 echo " $GENERATIONS generations"
299 echo " of"
300 echo "\"Life in the Slow Lane\""
301 echo "======================="
302
303
304 # -------- Display first generation. --------
305 Gen0=`echo ${initial[@]}`
306 display "$Gen0" # Display only.
307 echo; echo
308 echo "Generation $generation -- $alive alive"
309 # -------------------------------------------
310
311
312 let "generation += 1" # Increment generation count.
313 echo
314
315 # ------- Display second generation. -------
316 Cur=`echo ${initial[@]}`
317 next_gen "$Cur" # Update & display.
318 # ------------------------------------------
319
320 let "generation += 1" # Increment generation count.
321
322 # ------ Main loop for displaying subsequent generations ------
323 while [ "$generation" -le "$GENERATIONS" ]
324 do
325 Cur="$avar"
326 next_gen "$Cur"
327 let "generation += 1"
328 done
329 # ==============================================================
330
331 echo
332
333 exit 0
334
335 # --------------------------------------------------------------
336 # The grid in this script has a "boundary problem".
337 # The the top, bottom, and sides border on a void of dead cells.
338 # Exercise: Change the script to have the grid wrap around,
339 # + so that the left and right sides will "touch",
340 # + as will the top and bottom. |
Example A-12. Data file for "Game of Life"
1 # This is an example "generation 0" start-up file for "life.sh". 2 # -------------------------------------------------------------- 3 # The "gen0" file is a 10 x 10 grid using a period (.) for live cells, 4 #+ and an underscore (_) for dead ones. We cannot simply use spaces 5 #+ for dead cells in this file because of a peculiarity in Bash arrays. 6 # [Exercise for the reader: explain this.] 7 # 8 # Lines beginning with a '#' are comments, and the script ignores them. 9 __.__..___ 10 ___._.____ 11 ____.___.. 12 _._______. 13 ____._____ 14 ..__...___ 15 ____._____ 16 ___...____ 17 __.._..___ 18 _..___..__ |
+++
The following two scripts are by Mark Moraes of the University of Toronto. See the enclosed file "Moraes-COPYRIGHT" for permissions and restrictions.
Example A-13. behead: Removing mail and news message headers
1 #! /bin/sh 2 # Strips off the header from a mail/News message i.e. till the first 3 # empty line 4 # Mark Moraes, University of Toronto 5 6 # ==> These comments added by author of this document. 7 8 if [ $# -eq 0 ]; then 9 # ==> If no command line args present, then works on file redirected to stdin. 10 sed -e '1,/^$/d' -e '/^[ ]*$/d' 11 # --> Delete empty lines and all lines until 12 # --> first one beginning with white space. 13 else 14 # ==> If command line args present, then work on files named. 15 for i do 16 sed -e '1,/^$/d' -e '/^[ ]*$/d' $i 17 # --> Ditto, as above. 18 done 19 fi 20 21 # ==> Exercise: Add error checking and other options. 22 # ==> 23 # ==> Note that the small sed script repeats, except for the arg passed. 24 # ==> Does it make sense to embed it in a function? Why or why not? |
Example A-14. ftpget: Downloading files via ftp
1 #! /bin/sh
2 # $Id: ftpget,v 1.2 91/05/07 21:15:43 moraes Exp $
3 # Script to perform batch anonymous ftp. Essentially converts a list of
4 # of command line arguments into input to ftp.
5 # Simple, and quick - written as a companion to ftplist
6 # -h specifies the remote host (default prep.ai.mit.edu)
7 # -d specifies the remote directory to cd to - you can provide a sequence
8 # of -d options - they will be cd'ed to in turn. If the paths are relative,
9 # make sure you get the sequence right. Be careful with relative paths -
10 # there are far too many symlinks nowadays.
11 # (default is the ftp login directory)
12 # -v turns on the verbose option of ftp, and shows all responses from the
13 # ftp server.
14 # -f remotefile[:localfile] gets the remote file into localfile
15 # -m pattern does an mget with the specified pattern. Remember to quote
16 # shell characters.
17 # -c does a local cd to the specified directory
18 # For example,
19 # ftpget -h expo.lcs.mit.edu -d contrib -f xplaces.shar:xplaces.sh \
20 # -d ../pub/R3/fixes -c ~/fixes -m 'fix*'
21 # will get xplaces.shar from ~ftp/contrib on expo.lcs.mit.edu, and put it in
22 # xplaces.sh in the current working directory, and get all fixes from
23 # ~ftp/pub/R3/fixes and put them in the ~/fixes directory.
24 # Obviously, the sequence of the options is important, since the equivalent
25 # commands are executed by ftp in corresponding order
26 #
27 # Mark Moraes (moraes@csri.toronto.edu), Feb 1, 1989
28 # ==> Angle brackets changed to parens, so Docbook won't get indigestion.
29 #
30
31
32 # ==> These comments added by author of this document.
33
34 # PATH=/local/bin:/usr/ucb:/usr/bin:/bin
35 # export PATH
36 # ==> Above 2 lines from original script probably superfluous.
37
38 TMPFILE=/tmp/ftp.$$
39 # ==> Creates temp file, using process id of script ($$)
40 # ==> to construct filename.
41
42 SITE=`domainname`.toronto.edu
43 # ==> 'domainname' similar to 'hostname'
44 # ==> May rewrite this to parameterize this for general use.
45
46 usage="Usage: $0 [-h remotehost] [-d remotedirectory]... [-f remfile:localfile]... \
47 [-c localdirectory] [-m filepattern] [-v]"
48 ftpflags="-i -n"
49 verbflag=
50 set -f # So we can use globbing in -m
51 set x `getopt vh:d:c:m:f: $*`
52 if [ $? != 0 ]; then
53 echo $usage
54 exit 65
55 fi
56 shift
57 trap 'rm -f ${TMPFILE} ; exit' 0 1 2 3 15
58 echo "user anonymous ${USER-gnu}@${SITE} > ${TMPFILE}"
59 # ==> Added quotes (recommended in complex echoes).
60 echo binary >> ${TMPFILE}
61 for i in $* # ==> Parse command line args.
62 do
63 case $i in
64 -v) verbflag=-v; echo hash >> ${TMPFILE}; shift;;
65 -h) remhost=$2; shift 2;;
66 -d) echo cd $2 >> ${TMPFILE};
67 if [ x${verbflag} != x ]; then
68 echo pwd >> ${TMPFILE};
69 fi;
70 shift 2;;
71 -c) echo lcd $2 >> ${TMPFILE}; shift 2;;
72 -m) echo mget "$2" >> ${TMPFILE}; shift 2;;
73 -f) f1=`expr "$2" : "\([^:]*\).*"`; f2=`expr "$2" : "[^:]*:\(.*\)"`;
74 echo get ${f1} ${f2} >> ${TMPFILE}; shift 2;;
75 --) shift; break;;
76 esac
77 done
78 if [ $# -ne 0 ]; then
79 echo $usage
80 exit 65 # ==> Changed from "exit 2" to conform with standard.
81 fi
82 if [ x${verbflag} != x ]; then
83 ftpflags="${ftpflags} -v"
84 fi
85 if [ x${remhost} = x ]; then
86 remhost=prep.ai.mit.edu
87 # ==> Rewrite to match your favorite ftp site.
88 fi
89 echo quit >> ${TMPFILE}
90 # ==> All commands saved in tempfile.
91
92 ftp ${ftpflags} ${remhost} < ${TMPFILE}
93 # ==> Now, tempfile batch processed by ftp.
94
95 rm -f ${TMPFILE}
96 # ==> Finally, tempfile deleted (you may wish to copy it to a logfile).
97
98
99 # ==> Exercises:
100 # ==> ---------
101 # ==> 1) Add error checking.
102 # ==> 2) Add bells & whistles. |
+
Antek Sawicki contributed the following script, which makes very clever use of the parameter substitution operators discussed in Section 9.3.
Example A-15. password: Generating random 8-character passwords
1 #!/bin/bash
2 # May need to be invoked with #!/bin/bash2 on older machines.
3 #
4 # Random password generator for bash 2.x by Antek Sawicki <tenox@tenox.tc>,
5 # who generously gave permission to the document author to use it here.
6 #
7 # ==> Comments added by document author ==>
8
9
10 MATRIX="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
11 LENGTH="8"
12 # ==> May change 'LENGTH' for longer password, of course.
13
14
15 while [ "${n:=1}" -le "$LENGTH" ]
16 # ==> Recall that := is "default substitution" operator.
17 # ==> So, if 'n' has not been initialized, set it to 1.
18 do
19 PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"
20 # ==> Very clever, but tricky.
21
22 # ==> Starting from the innermost nesting...
23 # ==> ${#MATRIX} returns length of array MATRIX.
24
25 # ==> $RANDOM%${#MATRIX} returns random number between 1
26 # ==> and length of MATRIX - 1.
27
28 # ==> ${MATRIX:$(($RANDOM%${#MATRIX})):1}
29 # ==> returns expansion of MATRIX at random position, by length 1.
30 # ==> See {var:pos:len} parameter substitution in Section 3.3.1
31 # ==> and following examples.
32
33 # ==> PASS=... simply pastes this result onto previous PASS (concatenation).
34
35 # ==> To visualize this more clearly, uncomment the following line
36 # ==> echo "$PASS"
37 # ==> to see PASS being built up,
38 # ==> one character at a time, each iteration of the loop.
39
40 let n+=1
41 # ==> Increment 'n' for next pass.
42 done
43
44 echo "$PASS" # ==> Or, redirect to file, as desired.
45
46 exit 0 |
+
James R. Van Zandt contributed this script, which uses named pipes and, in his words, "really exercises quoting and escaping".
Example A-16. fifo: Making daily backups, using named pipes
1 #!/bin/bash
2 # ==> Script by James R. Van Zandt, and used here with his permission.
3
4 # ==> Comments added by author of this document.
5
6
7 HERE=`uname -n` # ==> hostname
8 THERE=bilbo
9 echo "starting remote backup to $THERE at `date +%r`"
10 # ==> `date +%r` returns time in 12-hour format, i.e. "08:08:34 PM".
11
12 # make sure /pipe really is a pipe and not a plain file
13 rm -rf /pipe
14 mkfifo /pipe # ==> Create a "named pipe", named "/pipe".
15
16 # ==> 'su xyz' runs commands as user "xyz".
17 # ==> 'ssh' invokes secure shell (remote login client).
18 su xyz -c "ssh $THERE \"cat >/home/xyz/backup/${HERE}-daily.tar.gz\" < /pipe"&
19 cd /
20 tar -czf - bin boot dev etc home info lib man root sbin share usr var >/pipe
21 # ==> Uses named pipe, /pipe, to communicate between processes:
22 # ==> 'tar/gzip' writes to /pipe and 'ssh' reads from /pipe.
23
24 # ==> The end result is this backs up the main directories, from / on down.
25
26 # ==> What are the advantages of a "named pipe" in this situation,
27 # ==> as opposed to an "anonymous pipe", with |?
28 # ==> Will an anonymous pipe even work here?
29
30
31 exit 0 |
+
Stephane Chazelas contributed the following script to demonstrate that generating prime numbers does not require arrays.
Example A-17. Generating prime numbers using the modulo operator
1 #!/bin/bash
2 # primes.sh: Generate prime numbers, without using arrays.
3 # Script contributed by Stephane Chazelas.
4
5 # This does *not* use the classic "Sieve of Eratosthenes" algorithm,
6 #+ but instead uses the more intuitive method of testing each candidate number
7 #+ for factors (divisors), using the "%" modulo operator.
8
9
10 LIMIT=1000 # Primes 2 - 1000
11
12 Primes()
13 {
14 (( n = $1 + 1 )) # Bump to next integer.
15 shift # Next parameter in list.
16 # echo "_n=$n i=$i_"
17
18 if (( n == LIMIT ))
19 then echo $*
20 return
21 fi
22
23 for i; do # "i" gets set to "@", previous values of $n.
24 # echo "-n=$n i=$i-"
25 (( i * i > n )) && break # Optimization.
26 (( n % i )) && continue # Sift out non-primes using modulo operator.
27 Primes $n $@ # Recursion inside loop.
28 return
29 done
30
31 Primes $n $@ $n # Recursion outside loop.
32 # Successively accumulate positional parameters.
33 # "$@" is the accumulating list of primes.
34 }
35
36 Primes 1
37
38 exit 0
39
40 # Uncomment lines 17 and 25 to help figure out what is going on.
41
42 # Compare the speed of this algorithm for generating primes
43 # with the Sieve of Eratosthenes (ex68.sh).
44
45 # Exercise: Rewrite this script without recursion, for faster execution. |
+
Jordi Sanfeliu gave permission to use his elegant tree script.
Example A-18. tree: Displaying a directory tree
1 #!/bin/sh
2 # @(#) tree 1.1 30/11/95 by Jordi Sanfeliu
3 # email: mikaku@fiwix.org
4 #
5 # Initial version: 1.0 30/11/95
6 # Next version : 1.1 24/02/97 Now, with symbolic links
7 # Patch by : Ian Kjos, to support unsearchable dirs
8 # email: beth13@mail.utexas.edu
9 #
10 # Tree is a tool for view the directory tree (obvious :-) )
11 #
12
13 # ==> 'Tree' script used here with the permission of its author, Jordi Sanfeliu.
14 # ==> Comments added by the author of this document.
15 # ==> Argument quoting added.
16
17
18 search () {
19 for dir in `echo *`
20 # ==> `echo *` lists all the files in current working directory, without line breaks.
21 # ==> Similar effect to for dir in *
22 # ==> but "dir in `echo *`" will not handle filenames with blanks.
23 do
24 if [ -d "$dir" ] ; then # ==> If it is a directory (-d)...
25 zz=0 # ==> Temp variable, keeping track of directory level.
26 while [ $zz != $deep ] # Keep track of inner nested loop.
27 do
28 echo -n "| " # ==> Display vertical connector symbol,
29 # ==> with 2 spaces & no line feed in order to indent.
30 zz=`expr $zz + 1` # ==> Increment zz.
31 done
32 if [ -L "$dir" ] ; then # ==> If directory is a symbolic link...
33 echo "+---$dir" `ls -l $dir | sed 's/^.*'$dir' //'`
34 # ==> Display horiz. connector and list directory name, but...
35 # ==> delete date/time part of long listing.
36 else
37 echo "+---$dir" # ==> Display horizontal connector symbol...
38 # ==> and print directory name.
39 if cd "$dir" ; then # ==> If can move to subdirectory...
40 deep=`expr $deep + 1` # ==> Increment depth.
41 search # with recursivity ;-)
42 # ==> Function calls itself.
43 numdirs=`expr $numdirs + 1` # ==> Increment directory count.
44 fi
45 fi
46 fi
47 done
48 cd .. # ==> Up one directory level.
49 if [ "$deep" ] ; then # ==> If depth = 0 (returns TRUE)...
50 swfi=1 # ==> set flag showing that search is done.
51 fi
52 deep=`expr $deep - 1` # ==> Decrement depth.
53 }
54
55 # - Main -
56 if [ $# = 0 ] ; then
57 cd `pwd` # ==> No args to script, then use current working directory.
58 else
59 cd $1 # ==> Otherwise, move to indicated directory.
60 fi
61 echo "Initial directory = `pwd`"
62 swfi=0 # ==> Search finished flag.
63 deep=0 # ==> Depth of listing.
64 numdirs=0
65 zz=0
66
67 while [ "$swfi" != 1 ] # While flag not set...
68 do
69 search # ==> Call function after initializing variables.
70 done
71 echo "Total directories = $numdirs"
72
73 exit 0
74 # ==> Challenge: try to figure out exactly how this script works. |
Noah Friedman gave permission to use his string function script, which essentially reproduces some of the C-library string manipulation functions.
Example A-19. string functions: C-like string functions
1 #!/bin/bash
2
3 # string.bash --- bash emulation of string(3) library routines
4 # Author: Noah Friedman <friedman@prep.ai.mit.edu>
5 # ==> Used with his kind permission in this document.
6 # Created: 1992-07-01
7 # Last modified: 1993-09-29
8 # Public domain
9
10 # Conversion to bash v2 syntax done by Chet Ramey
11
12 # Commentary:
13 # Code:
14
15 #:docstring strcat:
16 # Usage: strcat s1 s2
17 #
18 # Strcat appends the value of variable s2 to variable s1.
19 #
20 # Example:
21 # a="foo"
22 # b="bar"
23 # strcat a b
24 # echo $a
25 # => foobar
26 #
27 #:end docstring:
28
29 ###;;;autoload ==> Autoloading of function commented out.
30 function strcat ()
31 {
32 local s1_val s2_val
33
34 s1_val=${!1} # indirect variable expansion
35 s2_val=${!2}
36 eval "$1"=\'"${s1_val}${s2_val}"\'
37 # ==> eval $1='${s1_val}${s2_val}' avoids problems,
38 # ==> if one of the variables contains a single quote.
39 }
40
41 #:docstring strncat:
42 # Usage: strncat s1 s2 $n
43 #
44 # Line strcat, but strncat appends a maximum of n characters from the value
45 # of variable s2. It copies fewer if the value of variabl s2 is shorter
46 # than n characters. Echoes result on stdout.
47 #
48 # Example:
49 # a=foo
50 # b=barbaz
51 # strncat a b 3
52 # echo $a
53 # => foobar
54 #
55 #:end docstring:
56
57 ###;;;autoload
58 function strncat ()
59 {
60 local s1="$1"
61 local s2="$2"
62 local -i n="$3"
63 local s1_val s2_val
64
65 s1_val=${!s1} # ==> indirect variable expansion
66 s2_val=${!s2}
67
68 if [ ${#s2_val} -gt ${n} ]; then
69 s2_val=${s2_val:0:$n} # ==> substring extraction
70 fi
71
72 eval "$s1"=\'"${s1_val}${s2_val}"\'
73 # ==> eval $1='${s1_val}${s2_val}' avoids problems,
74 # ==> if one of the variables contains a single quote.
75 }
76
77 #:docstring strcmp:
78 # Usage: strcmp $s1 $s2
79 #
80 # Strcmp compares its arguments and returns an integer less than, equal to,
81 # or greater than zero, depending on whether string s1 is lexicographically
82 # less than, equal to, or greater than string s2.
83 #:end docstring:
84
85 ###;;;autoload
86 function strcmp ()
87 {
88 [ "$1" = "$2" ] && return 0
89
90 [ "${1}" '<' "${2}" ] > /dev/null && return -1
91
92 return 1
93 }
94
95 #:docstring strncmp:
96 # Usage: strncmp $s1 $s2 $n
97 #
98 # Like strcmp, but makes the comparison by examining a maximum of n
99 # characters (n less than or equal to zero yields equality).
100 #:end docstring:
101
102 ###;;;autoload
103 function strncmp ()
104 {
105 if [ -z "${3}" -o "${3}" -le "0" ]; then
106 return 0
107 fi
108
109 if [ ${3} -ge ${#1} -a ${3} -ge ${#2} ]; then
110 strcmp "$1" "$2"
111 return $?
112 else
113 s1=${1:0:$3}
114 s2=${2:0:$3}
115 strcmp $s1 $s2
116 return $?
117 fi
118 }
119
120 #:docstring strlen:
121 # Usage: strlen s
122 #
123 # Strlen returns the number of characters in string literal s.
124 #:end docstring:
125
126 ###;;;autoload
127 function strlen ()
128 {
129 eval echo "\${#${1}}"
130 # ==> Returns the length of the value of the variable
131 # ==> whose name is passed as an argument.
132 }
133
134 #:docstring strspn:
135 # Usage: strspn $s1 $s2
136 #
137 # Strspn returns the length of the maximum initial segment of string s1,
138 # which consists entirely of characters from string s2.
139 #:end docstring:
140
141 ###;;;autoload
142 function strspn ()
143 {
144 # Unsetting IFS allows whitespace to be handled as normal chars.
145 local IFS=
146 local result="${1%%[!${2}]*}"
147
148 echo ${#result}
149 }
150
151 #:docstring strcspn:
152 # Usage: strcspn $s1 $s2
153 #
154 # Strcspn returns the length of the maximum initial segment of string s1,
155 # which consists entirely of characters not from string s2.
156 #:end docstring:
157
158 ###;;;autoload
159 function strcspn ()
160 {
161 # Unsetting IFS allows whitspace to be handled as normal chars.
162 local IFS=
163 local result="${1%%[${2}]*}"
164
165 echo ${#result}
166 }
167
168 #:docstring strstr:
169 # Usage: strstr s1 s2
170 #
171 # Strstr echoes a substring starting at the first occurrence of string s2 in
172 # string s1, or nothing if s2 does not occur in the string. If s2 points to
173 # a string of zero length, strstr echoes s1.
174 #:end docstring:
175
176 ###;;;autoload
177 function strstr ()
178 {
179 # if s2 points to a string of zero length, strstr echoes s1
180 [ ${#2} -eq 0 ] && { echo "$1" ; return 0; }
181
182 # strstr echoes nothing if s2 does not occur in s1
183 case "$1" in
184 *$2*) ;;
185 *) return 1;;
186 esac
187
188 # use the pattern matching code to strip off the match and everything
189 # following it
190 first=${1/$2*/}
191
192 # then strip off the first unmatched portion of the string
193 echo "${1##$first}"
194 }
195
196 #:docstring strtok:
197 # Usage: strtok s1 s2
198 #
199 # Strtok considers the string s1 to consist of a sequence of zero or more
200 # text tokens separated by spans of one or more characters from the
201 # separator string s2. The first call (with a non-empty string s1
202 # specified) echoes a string consisting of the first token on stdout. The
203 # function keeps track of its position in the string s1 between separate
204 # calls, so that subsequent calls made with the first argument an empty
205 # string will work through the string immediately following that token. In
206 # this way subsequent calls will work through the string s1 until no tokens
207 # remain. The separator string s2 may be different from call to call.
208 # When no token remains in s1, an empty value is echoed on stdout.
209 #:end docstring:
210
211 ###;;;autoload
212 function strtok ()
213 {
214 :
215 }
216
217 #:docstring strtrunc:
218 # Usage: strtrunc $n $s1 {$s2} {$...}
219 #
220 # Used by many functions like strncmp to truncate arguments for comparison.
221 # Echoes the first n characters of each string s1 s2 ... on stdout.
222 #:end docstring:
223
224 ###;;;autoload
225 function strtrunc ()
226 {
227 n=$1 ; shift
228 for z; do
229 echo "${z:0:$n}"
230 done
231 }
232
233 # provide string
234
235 # string.bash ends here
236
237
238 # ========================================================================== #
239 # ==> Everything below here added by the document author.
240
241 # ==> Suggested use of this script is to delete everything below here,
242 # ==> and "source" this file into your own scripts.
243
244 # strcat
245 string0=one
246 string1=two
247 echo
248 echo "Testing \"strcat\" function:"
249 echo "Original \"string0\" = $string0"
250 echo "\"string1\" = $string1"
251 strcat string0 string1
252 echo "New \"string0\" = $string0"
253 echo
254
255 # strlen
256 echo
257 echo "Testing \"strlen\" function:"
258 str=123456789
259 echo "\"str\" = $str"
260 echo -n "Length of \"str\" = "
261 strlen str
262 echo
263
264
265
266 # Exercise:
267 # --------
268 # Add code to test all the other string functions above.
269
270
271 exit 0 |
Michael Zick's complex array example uses the md5sum check sum command to encode directory information.
Example A-20. Directory information
1 #! /bin/bash
2 # directory-info.sh
3 # Parses and lists directory information.
4
5 # NOTE: Change lines 273 and 353 per "README" file.
6
7 # Michael Zick is the author of this script.
8 # Used here with his permission.
9
10 # Controls
11 # If overridden by command arguments, they must be in the order:
12 # Arg1: "Descriptor Directory"
13 # Arg2: "Exclude Paths"
14 # Arg3: "Exclude Directories"
15 #
16 # Environment Settings override Defaults.
17 # Command arguments override Environment Settings.
18
19 # Default location for content addressed file descriptors.
20 MD5UCFS=${1:-${MD5UCFS:-'/tmpfs/ucfs'}}
21
22 # Directory paths never to list or enter
23 declare -a \
24 EXCLUDE_PATHS=${2:-${EXCLUDE_PATHS:-'(/proc /dev /devfs /tmpfs)'}}
25
26 # Directories never to list or enter
27 declare -a \
28 EXCLUDE_DIRS=${3:-${EXCLUDE_DIRS:-'(ucfs lost+found tmp wtmp)'}}
29
30 # Files never to list or enter
31 declare -a \
32 EXCLUDE_FILES=${3:-${EXCLUDE_FILES:-'(core "Name with Spaces")'}}
33
34
35 # Here document used as a comment block.
36 : << LSfieldsDoc
37 # # # # # List Filesystem Directory Information # # # # #
38 #
39 # ListDirectory "FileGlob" "Field-Array-Name"
40 # or
41 # ListDirectory -of "FileGlob" "Field-Array-Filename"
42 # '-of' meaning 'output to filename'
43 # # # # #
44
45 String format description based on: ls (GNU fileutils) version 4.0.36
46
47 Produces a line (or more) formatted:
48 inode permissions hard-links owner group ...
49 32736 -rw------- 1 mszick mszick
50
51 size day month date hh:mm:ss year path
52 2756608 Sun Apr 20 08:53:06 2003 /home/mszick/core
53
54 Unless it is formatted:
55 inode permissions hard-links owner group ...
56 266705 crw-rw---- 1 root uucp
57
58 major minor day month date hh:mm:ss year path
59 4, 68 Sun Apr 20 09:27:33 2003 /dev/ttyS4
60 NOTE: that pesky comma after the major number
61
62 NOTE: the 'path' may be multiple fields:
63 /home/mszick/core
64 /proc/982/fd/0 -> /dev/null
65 /proc/982/fd/1 -> /home/mszick/.xsession-errors
66 /proc/982/fd/13 -> /tmp/tmpfZVVOCs (deleted)
67 /proc/982/fd/7 -> /tmp/kde-mszick/ksycoca
68 /proc/982/fd/8 -> socket:[11586]
69 /proc/982/fd/9 -> pipe:[11588]
70
71 If that isn't enough to keep your parser guessing,
72 either or both of the path components may be relative:
73 ../Built-Shared -> Built-Static
74 ../linux-2.4.20.tar.bz2 -> ../../../SRCS/linux-2.4.20.tar.bz2
75
76 The first character of the 11 (10?) character permissions field:
77 's' Socket
78 'd' Directory
79 'b' Block device
80 'c' Character device
81 'l' Symbolic link
82 NOTE: Hard links not marked - test for identical inode numbers
83 on identical filesystems.
84 All information about hard linked files are shared, except
85 for the names and the name's location in the directory system.
86 NOTE: A "Hard link" is known as a "File Alias" on some systems.
87 '-' An undistingushed file
88
89 Followed by three groups of letters for: User, Group, Others
90 Character 1: '-' Not readable; 'r' Readable
91 Character 2: '-' Not writable; 'w' Writable
92 Character 3, User and Group: Combined execute and special
93 '-' Not Executable, Not Special
94 'x' Executable, Not Special
95 's' Executable, Special
96 'S' Not Executable, Special
97 Character 3, Others: Combined execute and sticky (tacky?)
98 '-' Not Executable, Not Tacky
99 'x' Executable, Not Tacky
100 't' Executable, Tacky
101 'T' Not Executable, Tacky
102
103 Followed by an access indicator
104 Haven't tested this one, it may be the eleventh character
105 or it may generate another field
106 ' ' No alternate access
107 '+' Alternate access
108 LSfieldsDoc
109
110
111 ListDirectory()
112 {
113 local -a T
114 local -i of=0 # Default return in variable
115 # OLD_IFS=$IFS # Using BASH default ' \t\n'
116
117 case "$#" in
118 3) case "$1" in
119 -of) of=1 ; shift ;;
120 * ) return 1 ;;
121 esac ;;
122 2) : ;; # Poor man's "continue"
123 *) return 1 ;;
124 esac
125
126 # NOTE: the (ls) command is NOT quoted (")
127 T=( $(ls --inode --ignore-backups --almost-all --directory \
128 --full-time --color=none --time=status --sort=none \
129 --format=long $1) )
130
131 case $of in
132 # Assign T back to the array whose name was passed as $2
133 0) eval $2=\( \"\$\{T\[@\]\}\" \) ;;
134 # Write T into filename passed as $2
135 1) echo "${T[@]}" > "$2" ;;
136 esac
137 return 0
138 }
139
140 # # # # # Is that string a legal number? # # # # #
141 #
142 # IsNumber "Var"
143 # # # # # There has to be a better way, sigh...
144
145 IsNumber()
146 {
147 local -i int
148 if [ $# -eq 0 ]
149 then
150 return 1
151 else
152 (let int=$1) 2>/dev/null
153 return $? # Exit status of the let thread
154 fi
155 }
156
157 # # # # # Index Filesystem Directory Information # # # # #
158 #
159 # IndexList "Field-Array-Name" "Index-Array-Name"
160 # or
161 # IndexList -if Field-Array-Filename Index-Array-Name
162 # IndexList -of Field-Array-Name Index-Array-Filename
163 # IndexList -if -of Field-Array-Filename Index-Array-Filename
164 # # # # #
165
166 : << IndexListDoc
167 Walk an array of directory fields produced by ListDirectory
168
169 Having suppressed the line breaks in an otherwise line oriented
170 report, build an index to the array element which starts each line.
171
172 Each line gets two index entries, the first element of each line
173 (inode) and the element that holds the pathname of the file.
174
175 The first index entry pair (Line-Number==0) are informational:
176 Index-Array-Name[0] : Number of "Lines" indexed
177 Index-Array-Name[1] : "Current Line" pointer into Index-Array-Name
178
179 The following index pairs (if any) hold element indexes into
180 the Field-Array-Name per:
181 Index-Array-Name[Line-Number * 2] : The "inode" field element.
182 NOTE: This distance may be either +11 or +12 elements.
183 Index-Array-Name[(Line-Number * 2) + 1] : The "pathname" element.
184 NOTE: This distance may be a variable number of elements.
185 Next line index pair for Line-Number+1.
186 IndexListDoc
187
188
189
190 IndexList()
191 {
192 local -a LIST # Local of listname passed
193 local -a -i INDEX=( 0 0 ) # Local of index to return
194 local -i Lidx Lcnt
195 local -i if=0 of=0 # Default to variable names
196
197 case "$#" in # Simplistic option testing
198 0) return 1 ;;
199 1) return 1 ;;
200 2) : ;; # Poor man's continue
201 3) case "$1" in
202 -if) if=1 ;;
203 -of) of=1 ;;
204 * ) return 1 ;;
205 esac ; shift ;;
206 4) if=1 ; of=1 ; shift ; shift ;;
207 *) return 1
208 esac
209
210 # Make local copy of list
211 case "$if" in
212 0) eval LIST=\( \"\$\{$1\[@\]\}\" \) ;;
213 1) LIST=( $(cat $1) ) ;;
214 esac
215
216 # Grok (grope?) the array
217 Lcnt=${#LIST[@]}
218 Lidx=0
219 until (( Lidx >= Lcnt ))
220 do
221 if IsNumber ${LIST[$Lidx]}
222 then
223 local -i inode name
224 local ft
225 inode=Lidx
226 local m=${LIST[$Lidx+2]} # Hard Links field
227 ft=${LIST[$Lidx+1]:0:1} # Fast-Stat
228 case $ft in
229 b) ((Lidx+=12)) ;; # Block device
230 c) ((Lidx+=12)) ;; # Character device
231 *) ((Lidx+=11)) ;; # Anything else
232 esac
233 name=Lidx
234 case $ft in
235 -) ((Lidx+=1)) ;; # The easy one
236 b) ((Lidx+=1)) ;; # Block device
237 c) ((Lidx+=1)) ;; # Character device
238 d) ((Lidx+=1)) ;; # The other easy one
239 l) ((Lidx+=3)) ;; # At LEAST two more fields
240 # A little more elegance here would handle pipes,
241 #+ sockets, deleted files - later.
242 *) until IsNumber ${LIST[$Lidx]} || ((Lidx >= Lcnt))
243 do
244 ((Lidx+=1))
245 done
246 ;; # Not required
247 esac
248 INDEX[${#INDEX[*]}]=$inode
249 INDEX[${#INDEX[*]}]=$name
250 INDEX[0]=${INDEX[0]}+1 # One more "line" found
251 # echo "Line: ${INDEX[0]} Type: $ft Links: $m Inode: \
252 # ${LIST[$inode]} Name: ${LIST[$name]}"
253
254 else
255 ((Lidx+=1))
256 fi
257 done
258 case "$of" in
259 0) eval $2=\( \"\$\{INDEX\[@\]\}\" \) ;;
260 1) echo "${INDEX[@]}" > "$2" ;;
261 esac
262 return 0 # What could go wrong?
263 }
264
265 # # # # # Content Identify File # # # # #
266 #
267 # DigestFile Input-Array-Name Digest-Array-Name
268 # or
269 # DigestFile -if Input-FileName Digest-Array-Name
270 # # # # #
271
272 # Here document used as a comment block.
273 : <<DigestFilesDoc
274
275 The key (no pun intended) to a Unified Content File System (UCFS)
276 is to distinguish the files in the system based on their content.
277 Distinguishing files by their name is just, so, 20th Century.
278
279 The content is distinguished by computing a checksum of that content.
280 This version uses the md5sum program to generate a 128 bit checksum
281 representative of the file's contents.
282 There is a chance that two files having different content might
283 generate the same checksum using md5sum (or any checksum). Should
284 that become a problem, then the use of md5sum can be replace by a
285 cyrptographic signature. But until then...
286
287 The md5sum program is documented as outputting three fields (and it
288 does), but when read it appears as two fields (array elements). This
289 is caused by the lack of whitespace between the second and third field.
290 So this function gropes the md5sum output and returns:
291 [0] 32 character checksum in hexidecimal (UCFS filename)
292 [1] Single character: ' ' text file, '*' binary file
293 [2] Filesystem (20th Century Style) name
294 Note: That name may be the character '-' indicating STDIN read.
295
296 DigestFilesDoc
297
298
299
300 DigestFile()
301 {
302 local if=0 # Default, variable name
303 local -a T1 T2
304
305 case "$#" in
306 3) case "$1" in
307 -if) if=1 ; shift ;;
308 * ) return 1 ;;
309 esac ;;
310 2) : ;; # Poor man's "continue"
311 *) return 1 ;;
312 esac
313
314 case $if in
315 0) eval T1=\( \"\$\{$1\[@\]\}\" \)
316 T2=( $(echo ${T1[@]} | md5sum -) )
317 ;;
318 1) T2=( $(md5sum $1) )
319 ;;
320 esac
321
322 case ${#T2[@]} in
323 0) return 1 ;;
324 1) return 1 ;;
325 2) case ${T2[1]:0:1} in # SanScrit-2.0.5
326 \*) T2[${#T2[@]}]=${T2[1]:1}
327 T2[1]=\*
328 ;;
329 *) T2[${#T2[@]}]=${T2[1]}
330 T2[1]=" "
331 ;;
332 esac
333 ;;
334 3) : ;; # Assume it worked
335 *) return 1 ;;
336 esac
337
338 local -i len=${#T2[0]}
339 if [ $len -ne 32 ] ; then return 1 ; fi
340 eval $2=\( \"\$\{T2\[@\]\}\" \)
341 }
342
343 # # # # # Locate File # # # # #
344 #
345 # LocateFile [-l] FileName Location-Array-Name
346 # or
347 # LocateFile [-l] -of FileName Location-Array-FileName
348 # # # # #
349
350 # A file location is Filesystem-id and inode-number
351
352 # Here document used as a comment block.
353 : <<StatFieldsDoc
354 Based on stat, version 2.2
355 stat -t and stat -lt fields
356 [0] name
357 [1] Total size
358 File - number of bytes
359 Symbolic link - string length of pathname
360 [2] Number of (512 byte) blocks allocated
361 [3] File type and Access rights (hex)
362 [4] User ID of owner
363 [5] Group ID of owner
364 [6] Device number
365 [7] Inode number
366 [8] Number of hard links
367 [9] Device type (if inode device) Major
368 [10] Device type (if inode device) Minor
369 [11] Time of last access
370 May be disabled in 'mount' with noatime
371 atime of files changed by exec, read, pipe, utime, mknod (mmap?)
372 atime of directories changed by addition/deletion of files
373 [12] Time of last modification
374 mtime of files changed by write, truncate, utime, mknod
375 mtime of directories changed by addtition/deletion of files
376 [13] Time of last change
377 ctime reflects time of changed inode information (owner, group
378 permissions, link count
379 -*-*- Per:
380 Return code: 0
381 Size of array: 14
382 Contents of array
383 Element 0: /home/mszick
384 Element 1: 4096
385 Element 2: 8
386 Element 3: 41e8
387 Element 4: 500
388 Element 5: 500
389 Element 6: 303
390 Element 7: 32385
391 Element 8: 22
392 Element 9: 0
393 Element 10: 0
394 Element 11: 1051221030
395 Element 12: 1051214068
396 Element 13: 1051214068
397
398 For a link in the form of linkname -> realname
399 stat -t linkname returns the linkname (link) information
400 stat -lt linkname returns the realname information
401
402 stat -tf and stat -ltf fields
403 [0] name
404 [1] ID-0? # Maybe someday, but Linux stat structure
405 [2] ID-0? # does not have either LABEL nor UUID
406 # fields, currently information must come
407 # from file-system specific utilities
408 These will be munged into:
409 [1] UUID if possible
410 [2] Volume Label if possible
411 Note: 'mount -l' does return the label and could return the UUID
412
413 [3] Maximum length of filenames
414 [4] Filesystem type
415 [5] Total blocks in the filesystem
416 [6] Free blocks
417 [7] Free blocks for non-root user(s)
418 [8] Block size of the filesystem
419 [9] Total inodes
420 [10] Free inodes
421
422 -*-*- Per:
423 Return code: 0
424 Size of array: 11
425 Contents of array
426 Element 0: /home/mszick
427 Element 1: 0
428 Element 2: 0
429 Element 3: 255
430 Element 4: ef53
431 Element 5: 2581445
432 Element 6: 2277180
433 Element 7: 2146050
434 Element 8: 4096
435 Element 9: 1311552
436 Element 10: 1276425
437
438 StatFieldsDoc
439
440
441 # LocateFile [-l] FileName Location-Array-Name
442 # LocateFile [-l] -of FileName Location-Array-FileName
443
444 LocateFile()
445 {
446 local -a LOC LOC1 LOC2
447 local lk="" of=0
448
449 case "$#" in
450 0) return 1 ;;
451 1) return 1 ;;
452 2) : ;;
453 *) while (( "$#" > 2 ))
454 do
455 case "$1" in
456 -l) lk=-1 ;;
457 -of) of=1 ;;
458 *) return 1 ;;
459 esac
460 shift
461 done ;;
462 esac
463
464 # More Sanscrit-2.0.5
465 # LOC1=( $(stat -t $lk $1) )
466 # LOC2=( $(stat -tf $lk $1) )
467 # Uncomment above two lines if system has "stat" command installed.
468 LOC=( ${LOC1[@]:0:1} ${LOC1[@]:3:11}
469 ${LOC2[@]:1:2} ${LOC2[@]:4:1} )
470
471 case "$of" in
472 0) eval $2=\( \"\$\{LOC\[@\]\}\" \) ;;
473 1) echo "${LOC[@]}" > "$2" ;;
474 esac
475 return 0
476 # Which yields (if you are lucky, and have "stat" installed)
477 # -*-*- Location Discriptor -*-*-
478 # Return code: 0
479 # Size of array: 15
480 # Contents of array
481 # Element 0: /home/mszick 20th Century name
482 # Element 1: 41e8 Type and Permissions
483 # Element 2: 500 User
484 # Element 3: 500 Group
485 # Element 4: 303 Device
486 # Element 5: 32385 inode
487 # Element 6: 22 Link count
488 # Element 7: 0 Device Major
489 # Element 8: 0 Device Minor
490 # Element 9: 1051224608 Last Access
491 # Element 10: 1051214068 Last Modify
492 # Element 11: 1051214068 Last Status
493 # Element 12: 0 UUID (to be)
494 # Element 13: 0 Volume Label (to be)
495 # Element 14: ef53 Filesystem type
496 }
497
498
499
500 # And then there was some test code
501
502 ListArray() # ListArray Name
503 {
504 local -a Ta
505
506 eval Ta=\( \"\$\{$1\[@\]\}\" \)
507 echo
508 echo "-*-*- List of Array -*-*-"
509 echo "Size of array $1: ${#Ta[*]}"
510 echo "Contents of array $1:"
511 for (( i=0 ; i<${#Ta[*]} ; i++ ))
512 do
513 echo -e "\tElement $i: ${Ta[$i]}"
514 done
515 return 0
516 }
517
518 declare -a CUR_DIR
519 # For small arrays
520 ListDirectory "${PWD}" CUR_DIR
521 ListArray CUR_DIR
522
523 declare -a DIR_DIG
524 DigestFile CUR_DIR DIR_DIG
525 echo "The new \"name\" (checksum) for ${CUR_DIR[9]} is ${DIR_DIG[0]}"
526
527 declare -a DIR_ENT
528 # BIG_DIR # For really big arrays - use a temporary file in ramdisk
529 # BIG-DIR # ListDirectory -of "${CUR_DIR[11]}/*" "/tmpfs/junk2"
530 ListDirectory "${CUR_DIR[11]}/*" DIR_ENT
531
532 declare -a DIR_IDX
533 # BIG-DIR # IndexList -if "/tmpfs/junk2" DIR_IDX
534 IndexList DIR_ENT DIR_IDX
535
536 declare -a IDX_DIG
537 # BIG-DIR # DIR_ENT=( $(cat /tmpfs/junk2) )
538 # BIG-DIR # DigestFile -if /tmpfs/junk2 IDX_DIG
539 DigestFile DIR_ENT IDX_DIG
540 # Small (should) be able to parallize IndexList & DigestFile
541 # Large (should) be able to parallize IndexList & DigestFile & the assignment
542 echo "The \"name\" (checksum) for the contents of ${PWD} is ${IDX_DIG[0]}"
543
544 declare -a FILE_LOC
545 LocateFile ${PWD} FILE_LOC
546 ListArray FILE_LOC
547
548 exit 0 |
Stephane Chazelas demonstrates object-oriented programming in a Bash script.
Example A-21. Object-oriented database
1 #!/bin/bash
2 # obj-oriented.sh: Object-oriented programming in a shell script.
3 # Script by Stephane Chazelas.
4
5
6 person.new() # Looks almost like a class declaration in C++.
7 {
8 local obj_name=$1 name=$2 firstname=$3 birthdate=$4
9
10 eval "$obj_name.set_name() {
11 eval \"$obj_name.get_name() {
12 echo \$1
13 }\"
14 }"
15
16 eval "$obj_name.set_firstname() {
17 eval \"$obj_name.get_firstname() {
18 echo \$1
19 }\"
20 }"
21
22 eval "$obj_name.set_birthdate() {
23 eval \"$obj_name.get_birthdate() {
24 echo \$1
25 }\"
26 eval \"$obj_name.show_birthdate() {
27 echo \$(date -d \"1/1/1970 0:0:\$1 GMT\")
28 }\"
29 eval \"$obj_name.get_age() {
30 echo \$(( (\$(date +%s) - \$1) / 3600 / 24 / 365 ))
31 }\"
32 }"
33
34 $obj_name.set_name $name
35 $obj_name.set_firstname $firstname
36 $obj_name.set_birthdate $birthdate
37 }
38
39 echo
40
41 person.new self Bozeman Bozo 101272413
42 # Create an instance of "person.new" (actually passing args to the function).
43
44 self.get_firstname # Bozo
45 self.get_name # Bozeman
46 self.get_age # 28
47 self.get_birthdate # 101272413
48 self.show_birthdate # Sat Mar 17 20:13:33 MST 1973
49
50 echo
51
52 # typeset -f
53 # to see the created functions (careful, it scrolls off the page).
54
55 exit 0 |