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 script is useful when writing man page source. 5 # It lets you look at the intermediate results on the fly 6 #+ while working on it. 7 8 E_WRONGARGS=65 9 10 if [ -z "$1" ] 11 then 12 echo "Usage: `basename $0` filename" 13 exit $E_WRONGARGS 14 fi 15 16 # --------------------------- 17 groff -Tascii -man $1 | less 18 # From the man page for groff. 19 # --------------------------- 20 21 # If the man page includes tables and/or equations, 22 #+ then the above code will barf. 23 # The following line can handle such cases. 24 # 25 # gtbl < "$1" | geqn -Tlatin1 | groff -Tlatin1 -mtty-char -man 26 # 27 # Thanks, S.C. 28 29 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 rather 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 16 and 24 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 |
How do you keep the shell from expanding and reinterpreting strings?
Example A-22. Protecting literal strings
1 #! /bin/bash 2 # protect_literal.sh 3 4 # set -vx 5 6 :<<-'_Protect_Literal_String_Doc' 7 8 Copyright (c) Michael S. Zick, 2003; All Rights Reserved 9 License: Unrestricted reuse in any form, for any purpose. 10 Warranty: None 11 Revision: $ID$ 12 13 Documentation redirected to the Bash no-operation. 14 Bash will '/dev/null' this block when the script is first read. 15 (Uncomment the above set command to see this action.) 16 17 Remove the first (Sha-Bang) line when sourcing this as a library 18 procedure. Also comment out the example use code in the two 19 places where shown. 20 21 22 Usage: 23 _protect_literal_str 'Whatever string meets your ${fancy}' 24 Just echos the argument to standard out, hard quotes 25 restored. 26 27 $(_protect_literal_str 'Whatever string meets your ${fancy}') 28 as the right-hand-side of an assignment statement. 29 30 Does: 31 As the right-hand-side of an assignment, preserves the 32 hard quotes protecting the contents of the literal during 33 assignment. 34 35 Notes: 36 The strange names (_*) are used to avoid trampling on 37 the user's chosen names when this is sourced as a 38 library. 39 40 _Protect_Literal_String_Doc 41 42 # The 'for illustration' function form 43 44 _protect_literal_str() { 45 46 # Pick an un-used, non-printing character as local IFS. 47 # Not required, but shows that we are ignoring it. 48 local IFS=$'\x1B' # \ESC character 49 50 # Enclose the All-Elements-Of in hard quotes during assignment. 51 local tmp=$'\x27'$@$'\x27' 52 # local tmp=$'\''$@$'\'' # Even uglier. 53 54 local len=${#tmp} # Info only. 55 echo $tmp is $len long. # Output AND information. 56 } 57 58 # This is the short-named version. 59 _pls() { 60 local IFS=$'x1B' # \ESC character (not required) 61 echo $'\x27'$@$'\x27' # Hard quoted parameter glob 62 } 63 64 # :<<-'_Protect_Literal_String_Test' 65 # # # Remove the above "# " to disable this code. # # # 66 67 # See how that looks when printed. 68 echo 69 echo "- - Test One - -" 70 _protect_literal_str 'Hello $user' 71 _protect_literal_str 'Hello "${username}"' 72 echo 73 74 # Which yields: 75 # - - Test One - - 76 # 'Hello $user' is 13 long. 77 # 'Hello "${username}"' is 21 long. 78 79 # Looks as expected, but why all of the trouble? 80 # The difference is hidden inside the Bash internal order 81 #+ of operations. 82 # Which shows when you use it on the RHS of an assignment. 83 84 # Declare an array for test values. 85 declare -a arrayZ 86 87 # Assign elements with various types of quotes and escapes. 88 arrayZ=( zero "$(_pls 'Hello ${Me}')" 'Hello ${You}' "\'Pass: ${pw}\'" ) 89 90 # Now list that array and see what is there. 91 echo "- - Test Two - -" 92 for (( i=0 ; i<${#arrayZ[*]} ; i++ )) 93 do 94 echo Element $i: ${arrayZ[$i]} is: ${#arrayZ[$i]} long. 95 done 96 echo 97 98 # Which yields: 99 # - - Test Two - - 100 # Element 0: zero is: 4 long. # Our marker element 101 # Element 1: 'Hello ${Me}' is: 13 long. # Our "$(_pls '...' )" 102 # Element 2: Hello ${You} is: 12 long. # Quotes are missing 103 # Element 3: \'Pass: \' is: 10 long. # ${pw} expanded to nothing 104 105 # Now make an assignment with that result. 106 declare -a array2=( ${arrayZ[@]} ) 107 108 # And print what happened. 109 echo "- - Test Three - -" 110 for (( i=0 ; i<${#array2[*]} ; i++ )) 111 do 112 echo Element $i: ${array2[$i]} is: ${#array2[$i]} long. 113 done 114 echo 115 116 # Which yields: 117 # - - Test Three - - 118 # Element 0: zero is: 4 long. # Our marker element. 119 # Element 1: Hello ${Me} is: 11 long. # Intended result. 120 # Element 2: Hello is: 5 long. # ${You} expanded to nothing. 121 # Element 3: 'Pass: is: 6 long. # Split on the whitespace. 122 # Element 4: ' is: 1 long. # The end quote is here now. 123 124 # Our Element 1 has had its leading and trailing hard quotes stripped. 125 # Although not shown, leading and trailing whitespace is also stripped. 126 # Now that the string contents are set, Bash will always, internally, 127 #+ hard quote the contents as required during its operations. 128 129 # Why? 130 # Considering our "$(_pls 'Hello ${Me}')" construction: 131 # " ... " -> Expansion required, strip the quotes. 132 # $( ... ) -> Replace with the result of..., strip this. 133 # _pls ' ... ' -> called with literal arguments, strip the quotes. 134 # The result returned includes hard quotes; BUT the above processing 135 #+ has already been done, so they become part of the value assigned. 136 # 137 # Similarly, during further usage of the string variable, the ${Me} 138 #+ is part of the contents (result) and survives any operations 139 # (Until explicitly told to evaluate the string). 140 141 # Hint: See what happens when the hard quotes ($'\x27') are replaced 142 #+ with soft quotes ($'\x22') in the above procedures. 143 # Interesting also is to remove the addition of any quoting. 144 145 # _Protect_Literal_String_Test 146 # # # Remove the above "# " to disable this code. # # # 147 148 exit 0 |
What if you want the shell to expand and reinterpret strings?
Example A-23. Unprotecting literal strings
1 #! /bin/bash 2 # unprotect_literal.sh 3 4 # set -vx 5 6 :<<-'_UnProtect_Literal_String_Doc' 7 8 Copyright (c) Michael S. Zick, 2003; All Rights Reserved 9 License: Unrestricted reuse in any form, for any purpose. 10 Warranty: None 11 Revision: $ID$ 12 13 Documentation redirected to the Bash no-operation. Bash will 14 '/dev/null' this block when the script is first read. 15 (Uncomment the above set command to see this action.) 16 17 Remove the first (Sha-Bang) line when sourcing this as a library 18 procedure. Also comment out the example use code in the two 19 places where shown. 20 21 22 Usage: 23 Complement of the "$(_pls 'Literal String')" function. 24 (See the protect_literal.sh example.) 25 26 StringVar=$(_upls ProtectedSringVariable) 27 28 Does: 29 When used on the right-hand-side of an assignment statement; 30 makes the substitions embedded in the protected string. 31 32 Notes: 33 The strange names (_*) are used to avoid trampling on 34 the user's chosen names when this is sourced as a 35 library. 36 37 38 _UnProtect_Literal_String_Doc 39 40 _upls() { 41 local IFS=$'x1B' # \ESC character (not required) 42 eval echo $@ # Substitution on the glob. 43 } 44 45 # :<<-'_UnProtect_Literal_String_Test' 46 # # # Remove the above "# " to disable this code. # # # 47 48 49 _pls() { 50 local IFS=$'x1B' # \ESC character (not required) 51 echo $'\x27'$@$'\x27' # Hard quoted parameter glob 52 } 53 54 # Declare an array for test values. 55 declare -a arrayZ 56 57 # Assign elements with various types of quotes and escapes. 58 arrayZ=( zero "$(_pls 'Hello ${Me}')" 'Hello ${You}' "\'Pass: ${pw}\'" ) 59 60 # Now make an assignment with that result. 61 declare -a array2=( ${arrayZ[@]} ) 62 63 # Which yielded: 64 # - - Test Three - - 65 # Element 0: zero is: 4 long # Our marker element. 66 # Element 1: Hello ${Me} is: 11 long # Intended result. 67 # Element 2: Hello is: 5 long # ${You} expanded to nothing. 68 # Element 3: 'Pass: is: 6 long # Split on the whitespace. 69 # Element 4: ' is: 1 long # The end quote is here now. 70 71 # set -vx 72 73 # Initialize 'Me' to something for the embedded ${Me} substitution. 74 # This needs to be done ONLY just prior to evaluating the 75 #+ protected string. 76 # (This is why it was protected to begin with.) 77 78 Me="to the array guy." 79 80 # Set a string variable destination to the result. 81 newVar=$(_upls ${array2[1]}) 82 83 # Show what the contents are. 84 echo $newVar 85 86 # Do we really need a function to do this? 87 newerVar=$(eval echo ${array2[1]}) 88 echo $newerVar 89 90 # I guess not, but the _upls function gives us a place to hang 91 #+ the documentation on. 92 # This helps when we forget what a # construction like: 93 #+ $(eval echo ... ) means. 94 95 # What if Me isn't set when the protected string is evaluated? 96 unset Me 97 newestVar=$(_upls ${array2[1]}) 98 echo $newestVar 99 100 # Just gone, no hints, no runs, no errors. 101 102 # Why in the world? 103 # Setting the contents of a string variable containing character 104 #+ sequences that have a meaning to Bash is a general problem in 105 #+ script programming. 106 # 107 # This problem is now solved in eight lines of code 108 #+ (and four pages of description). 109 110 # Where is all this going? 111 # Dynamic content Web pages as an array of Bash strings. 112 # Content set per request by a Bash 'eval' command 113 #+ on the stored page template. 114 # Not intended to replace PHP, just an interesting thing to do. 115 ### 116 # Don't have a webserver application? 117 # No problem, check the example directory of the Bash source; 118 #+ there is a Bash script for that also. 119 120 # _UnProtect_Literal_String_Test 121 # # # Remove the above "# " to disable this code. # # # 122 123 exit 0 |
To end this section, a review of the basics . . . and more.
Example A-24. Basics Reviewed
1 #!/bin/bash 2 # basics-reviewed.bash 3 4 # File extension == *.bash == specific to Bash 5 6 # Copyright (c) Michael S. Zick, 2003; All rights reserved. 7 # License: Use in any form, for any purpose. 8 # Revision: $ID$ 9 # 10 # Edited for layout by M.C. 11 # (author of the "Advanced Bash Scripting Guide") 12 13 14 # This script tested under Bash versions 2.04, 2.05a and 2.05b. 15 # It may not work with earlier versions. 16 # This demonstration script generates one --intentional-- 17 #+ "command not found" error message. See line 394. 18 19 # The current Bash maintainer, Chet Ramey, has fixed the items noted 20 #+ for an upcoming version of Bash. 21 22 23 24 ###-------------------------------------------### 25 ### Pipe the output of this script to 'more' ### 26 ###+ else it will scroll off the page. ### 27 ### ### 28 ### You may also redirect its output ### 29 ###+ to a file for examination. ### 30 ###-------------------------------------------### 31 32 33 34 # Most of the following points are described at length in 35 #+ the text of the foregoing "Advanced Bash Scripting Guide." 36 # This demonstration script is mostly just a reorganized presentation. 37 # -- msz 38 39 # Variables are not typed unless otherwise specified. 40 41 # Variables are named. Names must contain a non-digit. 42 # File descriptor names (as in, for example: 2>&1) 43 #+ contain ONLY digits. 44 45 # Parameters and Bash array elements are numbered. 46 # (Parameters are very similar to Bash arrays.) 47 48 # A variable name may be undefined (null reference). 49 unset VarNull 50 51 # A variable name may be defined but empty (null contents). 52 VarEmpty='' # Two, adjacent, single quotes. 53 54 # A variable name my be defined and non-empty 55 VarSomething='Literal' 56 57 # A variable may contain: 58 # * A whole number as a signed 32-bit (or larger) integer 59 # * A string 60 # A variable may also be an array. 61 62 # A string may contain embedded blanks and may be treated 63 #+ as if it where a function name with optional arguments. 64 65 # The names of variables and the names of functions 66 #+ are in different namespaces. 67 68 69 # A variable may be defined as a Bash array either explicitly or 70 #+ implicitly by the syntax of the assignment statement. 71 # Explicit: 72 declare -a ArrayVar 73 74 75 76 # The echo command is a built-in. 77 echo $VarSomething 78 79 # The printf command is a built-in. 80 # Translate %s as: String-Format 81 printf %s $VarSomething # No linebreak specified, none output. 82 echo # Default, only linebreak output. 83 84 85 86 87 # The Bash parser word breaks on whitespace. 88 # Whitespace, or the lack of it is significant. 89 # (This holds true in general; there are, of course, exceptions.) 90 91 92 93 94 # Translate the DOLLAR_SIGN character as: Content-Of. 95 96 # Extended-Syntax way of writing Content-Of: 97 echo ${VarSomething} 98 99 # The ${ ... } Extended-Syntax allows more than just the variable 100 #+ name to be specified. 101 # In general, $VarSomething can always be written as: ${VarSomething}. 102 103 # Call this script with arguments to see the following in action. 104 105 106 107 # Outside of double-quotes, the special characters @ and * 108 #+ specify identical behavior. 109 # May be pronounced as: All-Elements-Of. 110 111 # Without specification of a name, they refer to the 112 #+ pre-defined parameter Bash-Array. 113 114 115 116 # Glob-Pattern references 117 echo $* # All parameters to script or function 118 echo ${*} # Same 119 120 # Bash disables filename expansion for Glob-Patterns. 121 # Only character matching is active. 122 123 124 # All-Elements-Of references 125 echo $@ # Same as above 126 echo ${@} # Same as above 127 128 129 130 131 # Within double-quotes, the behavior of Glob-Pattern references 132 #+ depends on the setting of IFS (Input Field Separator). 133 # Within double-quotes, All-Elements-Of references behave the same. 134 135 136 # Specifying only the name of a variable holding a string refers 137 #+ to all elements (characters) of a string. 138 139 140 # To specify an element (character) of a string, 141 #+ the Extended-Syntax reference notation (see below) MAY be used. 142 143 144 145 146 # Specifying only the name of a Bash array references 147 #+ the subscript zero element, 148 #+ NOT the FIRST DEFINED nor the FIRST WITH CONTENTS element. 149 150 # Additional qualification is needed to reference other elements, 151 #+ which means that the reference MUST be written in Extended-Syntax. 152 # The general form is: ${name[subscript]}. 153 154 # The string forms may also be used: ${name:subscript} 155 #+ for Bash-Arrays when referencing the subscript zero element. 156 157 158 # Bash-Arrays are implemented internally as linked lists, 159 #+ not as a fixed area of storage as in some programming languages. 160 161 162 # Characteristics of Bash arrays (Bash-Arrays): 163 # -------------------------------------------- 164 165 # If not otherwise specified, Bash-Array subscripts begin with 166 #+ subscript number zero. Literally: [0] 167 # This is called zero-based indexing. 168 ### 169 # If not otherwise specified, Bash-Arrays are subscript packed 170 #+ (sequential subscripts without subscript gaps). 171 ### 172 # Negative subscripts are not allowed. 173 ### 174 # Elements of a Bash-Array need not all be of the same type. 175 ### 176 # Elements of a Bash-Array may be undefined (null reference). 177 # That is, a Bash-Array my be "subscript sparse." 178 ### 179 # Elements of a Bash-Array may be defined and empty (null contents). 180 ### 181 # Elements of a Bash-Array may contain: 182 # * A whole number as a signed 32-bit (or larger) integer 183 # * A string 184 # * A string formated so that it appears to be a function name 185 # + with optional arguments 186 ### 187 # Defined elements of a Bash-Array may be undefined (unset). 188 # That is, a subscript packed Bash-Array may be changed 189 # + into a subscript sparse Bash-Array. 190 ### 191 # Elements may be added to a Bash-Array by defining an element 192 #+ not previously defined. 193 ### 194 # For these reasons, I have been calling them "Bash-Arrays". 195 # I'll return to the generic term "array" from now on. 196 # -- msz 197 198 199 200 201 # Demo time -- initialize the previously declared ArrayVar as a 202 #+ sparse array. 203 # (The 'unset ... ' is just documentation here.) 204 205 unset ArrayVar[0] # Just for the record 206 ArrayVar[1]=one # Unquoted literal 207 ArrayVar[2]='' # Defined, and empty 208 unset ArrayVar[3] # Just for the record 209 ArrayVar[4]='four' # Quoted literal 210 211 212 213 # Translate the %q format as: Quoted-Respecting-IFS-Rules. 214 echo 215 echo '- - Outside of double-quotes - -' 216 ### 217 printf %q ${ArrayVar[*]} # Glob-Pattern All-Elements-Of 218 echo 219 echo 'echo command:'${ArrayVar[*]} 220 ### 221 printf %q ${ArrayVar[@]} # All-Elements-Of 222 echo 223 echo 'echo command:'${ArrayVar[@]} 224 225 # The use of double-quotes may be translated as: Enable-Substitution. 226 227 # There are five cases recognized for the IFS setting. 228 229 echo 230 echo '- - Within double-quotes - Default IFS of space-tab-newline - -' 231 IFS=$'\x20'$'\x09'$'\x0A' # These three bytes, 232 #+ in exactly this order. 233 234 235 printf %q "${ArrayVar[*]}" # Glob-Pattern All-Elements-Of 236 echo 237 echo 'echo command:'"${ArrayVar[*]}" 238 ### 239 printf %q "${ArrayVar[@]}" # All-Elements-Of 240 echo 241 echo 'echo command:'"${ArrayVar[@]}" 242 243 244 echo 245 echo '- - Within double-quotes - First character of IFS is ^ - -' 246 # Any printing, non-whitespace character should do the same. 247 IFS='^'$IFS # ^ + space tab newline 248 ### 249 printf %q "${ArrayVar[*]}" # Glob-Pattern All-Elements-Of 250 echo 251 echo 'echo command:'"${ArrayVar[*]}" 252 ### 253 printf %q "${ArrayVar[@]}" # All-Elements-Of 254 echo 255 echo 'echo command:'"${ArrayVar[@]}" 256 257 258 echo 259 echo '- - Within double-quotes - Without whitespace in IFS - -' 260 IFS='^:%!' 261 ### 262 printf %q "${ArrayVar[*]}" # Glob-Pattern All-Elements-Of 263 echo 264 echo 'echo command:'"${ArrayVar[*]}" 265 ### 266 printf %q "${ArrayVar[@]}" # All-Elements-Of 267 echo 268 echo 'echo command:'"${ArrayVar[@]}" 269 270 271 echo 272 echo '- - Within double-quotes - IFS set and empty - -' 273 IFS='' 274 ### 275 printf %q "${ArrayVar[*]}" # Glob-Pattern All-Elements-Of 276 echo 277 echo 'echo command:'"${ArrayVar[*]}" 278 ### 279 printf %q "${ArrayVar[@]}" # All-Elements-Of 280 echo 281 echo 'echo command:'"${ArrayVar[@]}" 282 283 284 echo 285 echo '- - Within double-quotes - IFS undefined - -' 286 unset IFS 287 ### 288 printf %q "${ArrayVar[*]}" # Glob-Pattern All-Elements-Of 289 echo 290 echo 'echo command:'"${ArrayVar[*]}" 291 ### 292 printf %q "${ArrayVar[@]}" # All-Elements-Of 293 echo 294 echo 'echo command:'"${ArrayVar[@]}" 295 296 297 # Put IFS back to the default. 298 # Default is exactly these three bytes. 299 IFS=$'\x20'$'\x09'$'\x0A' # In exactly this order. 300 301 # Interpretation of the above outputs: 302 # A Glob-Pattern is I/O; the setting of IFS matters. 303 ### 304 # An All-Elements-Of does not consider IFS settings. 305 ### 306 # Note the different output using the echo command and the 307 #+ quoted format operator of the printf command. 308 309 310 # Recall: 311 # Parameters are similar to arrays and have the similar behaviors. 312 ### 313 # The above examples demonstrate the possible variations. 314 # To retain the shape of a sparse array, additional script 315 #+ programming is required. 316 ### 317 # The source code of Bash has a routine to output the 318 #+ [subscript]=value array assignment format. 319 # As of version 2.05b, that routine is not used, 320 #+ but that might change in future releases. 321 322 323 324 # The length of a string, measured in non-null elements (characters): 325 echo 326 echo '- - Non-quoted references - -' 327 echo 'Non-Null character count: '${#VarSomething}' characters.' 328 329 # test='Lit'$'\x00''eral' # $'\x00' is a null character. 330 # echo ${#test} # See that? 331 332 333 334 # The length of an array, measured in defined elements, 335 #+ including null content elements. 336 echo 337 echo 'Defined content count: '${#ArrayVar[@]}' elements.' 338 # That is NOT the maximum subscript (4). 339 # That is NOT the range of the subscripts (1 . . 4 inclusive). 340 # It IS the length of the linked list. 341 ### 342 # Both the maximum subscript and the range of the subscripts may 343 #+ be found with additional script programming. 344 345 # The length of a string, measured in non-null elements (characters): 346 echo 347 echo '- - Quoted, Glob-Pattern references - -' 348 echo 'Non-Null character count: '"${#VarSomething}"' characters.' 349 350 # The length of an array, measured in defined elements, 351 #+ including null-content elements. 352 echo 353 echo 'Defined element count: '"${#ArrayVar[*]}"' elements.' 354 355 # Interpretation: Substitution does not effect the ${# ... } operation. 356 # Suggestion: 357 # Always use the All-Elements-Of character 358 #+ if that is what is intended (independence from IFS). 359 360 361 362 # Define a simple function. 363 # I include an underscore in the name 364 #+ to make it distinctive in the examples below. 365 ### 366 # Bash separates variable names and function names 367 #+ in different namespaces. 368 # The Mark-One eyeball isn't that advanced. 369 ### 370 _simple() { 371 echo -n 'SimpleFunc'$@ # Newlines are swallowed in 372 } #+ result returned in any case. 373 374 375 # The ( ... ) notation invokes a command or function. 376 # The $( ... ) notation is pronounced: Result-Of. 377 378 379 # Invoke the function _simple 380 echo 381 echo '- - Output of function _simple - -' 382 _simple # Try passing arguments. 383 echo 384 # or 385 (_simple) # Try passing arguments. 386 echo 387 388 echo '- Is there a variable of that name? -' 389 echo $_simple not defined # No variable by that name. 390 391 # Invoke the result of function _simple (Error msg intended) 392 393 ### 394 $(_simple) # Gives an error message: 395 # line 394: SimpleFunc: command not found 396 # --------------------------------------- 397 398 echo 399 ### 400 401 # The first word of the result of function _simple 402 #+ is neither a valid Bash command nor the name of a defined function. 403 ### 404 # This demonstrates that the output of _simple is subject to evaluation. 405 ### 406 # Interpretation: 407 # A function can be used to generate in-line Bash commands. 408 409 410 # A simple function where the first word of result IS a bash command: 411 ### 412 _print() { 413 echo -n 'printf %q '$@ 414 } 415 416 echo '- - Outputs of function _print - -' 417 _print parm1 parm2 # An Output NOT A Command. 418 echo 419 420 $(_print parm1 parm2) # Executes: printf %q parm1 parm2 421 # See above IFS examples for the 422 #+ various possibilities. 423 echo 424 425 $(_print $VarSomething) # The predictable result. 426 echo 427 428 429 430 # Function variables 431 # ------------------ 432 433 echo 434 echo '- - Function variables - -' 435 # A variable may represent a signed integer, a string or an array. 436 # A string may be used like a function name with optional arguments. 437 438 # set -vx # Enable if desired 439 declare -f funcVar #+ in namespace of functions 440 441 funcVar=_print # Contains name of function. 442 $funcVar parm1 # Same as _print at this point. 443 echo 444 445 funcVar=$(_print ) # Contains result of function. 446 $funcVar # No input, No output. 447 $funcVar $VarSomething # The predictable result. 448 echo 449 450 funcVar=$(_print $VarSomething) # $VarSomething replaced HERE. 451 $funcVar # The expansion is part of the 452 echo #+ variable contents. 453 454 funcVar="$(_print $VarSomething)" # $VarSomething replaced HERE. 455 $funcVar # The expansion is part of the 456 echo #+ variable contents. 457 458 # The difference between the unquoted and the double-quoted versions 459 #+ above can be seen in the "protect_literal.sh" example. 460 # The first case above is processed as two, unquoted, Bash-Words. 461 # The second case above is processed as one, quoted, Bash-Word. 462 463 464 465 466 # Delayed replacement 467 # ------------------- 468 469 echo 470 echo '- - Delayed replacement - -' 471 funcVar="$(_print '$VarSomething')" # No replacement, single Bash-Word. 472 eval $funcVar # $VarSomething replaced HERE. 473 echo 474 475 VarSomething='NewThing' 476 eval $funcVar # $VarSomething replaced HERE. 477 echo 478 479 # Restore the original setting trashed above. 480 VarSomething=Literal 481 482 # There are a pair of functions demonstrated in the 483 #+ "protect_literal.sh" and "unprotect_literal.sh" examples. 484 # These are general purpose functions for delayed replacement literals 485 #+ containing variables. 486 487 488 489 490 491 # REVIEW: 492 # ------ 493 494 # A string can be considered a Classic-Array of elements (characters). 495 # A string operation applies to all elements (characters) of the string 496 #+ (in concept, anyway). 497 ### 498 # The notation: ${array_name[@]} represents all elements of the 499 #+ Bash-Array: array_name. 500 ### 501 # The Extended-Syntax string operations can be applied to all 502 #+ elements of an array. 503 ### 504 # This may be thought of as a For-Each operation on a vector of strings. 505 ### 506 # Parameters are similar to an array. 507 # The initialization of a parameter array for a script 508 #+ and a parameter array for a function only differ 509 #+ in the initialization of ${0}, which never changes its setting. 510 ### 511 # Subscript zero of the script's parameter array contains 512 #+ the name of the script. 513 ### 514 # Subscript zero of a function's parameter array DOES NOT contain 515 #+ the name of the function. 516 # The name of the current function is accessed by the $FUNCNAME variable. 517 ### 518 # A quick, review list follows (quick, not short). 519 520 echo 521 echo '- - Test (but not change) - -' 522 echo '- null reference -' 523 echo -n ${VarNull-'NotSet'}' ' # NotSet 524 echo ${VarNull} # NewLine only 525 echo -n ${VarNull:-'NotSet'}' ' # NotSet 526 echo ${VarNull} # Newline only 527 528 echo '- null contents -' 529 echo -n ${VarEmpty-'Empty'}' ' # Only the space 530 echo ${VarEmpty} # Newline only 531 echo -n ${VarEmpty:-'Empty'}' ' # Empty 532 echo ${VarEmpty} # Newline only 533 534 echo '- contents -' 535 echo ${VarSomething-'Content'} # Literal 536 echo ${VarSomething:-'Content'} # Literal 537 538 echo '- Sparse Array -' 539 echo ${ArrayVar[@]-'not set'} 540 541 # ASCII-Art time 542 # State Y==yes, N==no 543 # - :- 544 # Unset Y Y ${# ... } == 0 545 # Empty N Y ${# ... } == 0 546 # Contents N N ${# ... } > 0 547 548 # Either the first and/or the second part of the tests 549 #+ may be a command or a function invocation string. 550 echo 551 echo '- - Test 1 for undefined - -' 552 declare -i t 553 _decT() { 554 t=$t-1 555 } 556 557 # Null reference, set: t == -1 558 t=${#VarNull} # Results in zero. 559 ${VarNull- _decT } # Function executes, t now -1. 560 echo $t 561 562 # Null contents, set: t == 0 563 t=${#VarEmpty} # Results in zero. 564 ${VarEmpty- _decT } # _decT function NOT executed. 565 echo $t 566 567 # Contents, set: t == number of non-null characters 568 VarSomething='_simple' # Set to valid function name. 569 t=${#VarSomething} # non-zero length 570 ${VarSomething- _decT } # Function _simple executed. 571 echo $t # Note the Append-To action. 572 573 # Exercise: clean up that example. 574 unset t 575 unset _decT 576 VarSomething=Literal 577 578 echo 579 echo '- - Test and Change - -' 580 echo '- Assignment if null reference -' 581 echo -n ${VarNull='NotSet'}' ' # NotSet NotSet 582 echo ${VarNull} 583 unset VarNull 584 585 echo '- Assignment if null reference -' 586 echo -n ${VarNull:='NotSet'}' ' # NotSet NotSet 587 echo ${VarNull} 588 unset VarNull 589 590 echo '- No assignment if null contents -' 591 echo -n ${VarEmpty='Empty'}' ' # Space only 592 echo ${VarEmpty} 593 VarEmpty='' 594 595 echo '- Assignment if null contents -' 596 echo -n ${VarEmpty:='Empty'}' ' # Empty Empty 597 echo ${VarEmpty} 598 VarEmpty='' 599 600 echo '- No change if already has contents -' 601 echo ${VarSomething='Content'} # Literal 602 echo ${VarSomething:='Content'} # Literal 603 604 605 # "Subscript sparse" Bash-Arrays 606 ### 607 # Bash-Arrays are subscript packed, beginning with 608 #+ subscript zero unless otherwise specified. 609 ### 610 # The initialization of ArrayVar was one way 611 #+ to "otherwise specify". Here is the other way: 612 ### 613 echo 614 declare -a ArraySparse 615 ArraySparse=( [1]=one [2]='' [4]='four' ) 616 # [0]=null reference, [2]=null content, [3]=null reference 617 618 echo '- - Array-Sparse List - -' 619 # Within double-quotes, default IFS, Glob-Pattern 620 621 IFS=$'\x20'$'\x09'$'\x0A' 622 printf %q "${ArraySparse[*]}" 623 echo 624 625 # Note that the output does not distinguish between "null content" 626 #+ and "null reference". 627 # Both print as escaped whitespace. 628 ### 629 # Note also that the output does NOT contain escaped whitespace 630 #+ for the "null reference(s)" prior to the first defined element. 631 ### 632 # This behavior of 2.04, 2.05a and 2.05b has been reported 633 #+ and may change in a future version of Bash. 634 635 # To output a sparse array and maintain the [subscript]=value 636 #+ relationship without change requires a bit of programming. 637 # One possible code fragment: 638 ### 639 # local l=${#ArraySparse[@]} # Count of defined elements 640 # local f=0 # Count of found subscripts 641 # local i=0 # Subscript to test 642 ( # Anonymous in-line function 643 for (( l=${#ArraySparse[@]}, f = 0, i = 0 ; f < l ; i++ )) 644 do 645 # 'if defined then...' 646 ${ArraySparse[$i]+ eval echo '\ ['$i']='${ArraySparse[$i]} ; (( f++ )) } 647 done 648 ) 649 650 # The reader coming upon the above code fragment cold 651 #+ might want to review "command lists" and "multiple commands on a line" 652 #+ in the text of the foregoing "Advanced Bash Scripting Guide." 653 ### 654 # Note: 655 # The "read -a array_name" version of the "read" command 656 #+ begins filling array_name at subscript zero. 657 # ArraySparse does not define a value at subscript zero. 658 ### 659 # The user needing to read/write a sparse array to either 660 #+ external storage or a communications socket must invent 661 #+ a read/write code pair suitable for their purpose. 662 ### 663 # Exercise: clean it up. 664 665 unset ArraySparse 666 667 echo 668 echo '- - Conditional alternate (But not change)- -' 669 echo '- No alternate if null reference -' 670 echo -n ${VarNull+'NotSet'}' ' 671 echo ${VarNull} 672 unset VarNull 673 674 echo '- No alternate if null reference -' 675 echo -n ${VarNull:+'NotSet'}' ' 676 echo ${VarNull} 677 unset VarNull 678 679 echo '- Alternate if null contents -' 680 echo -n ${VarEmpty+'Empty'}' ' # Empty 681 echo ${VarEmpty} 682 VarEmpty='' 683 684 echo '- No alternate if null contents -' 685 echo -n ${VarEmpty:+'Empty'}' ' # Space only 686 echo ${VarEmpty} 687 VarEmpty='' 688 689 echo '- Alternate if already has contents -' 690 691 # Alternate literal 692 echo -n ${VarSomething+'Content'}' ' # Content Literal 693 echo ${VarSomething} 694 695 # Invoke function 696 echo -n ${VarSomething:+ $(_simple) }' ' # SimpleFunc Literal 697 echo ${VarSomething} 698 echo 699 700 echo '- - Sparse Array - -' 701 echo ${ArrayVar[@]+'Empty'} # An array of 'Empty'(ies) 702 echo 703 704 echo '- - Test 2 for undefined - -' 705 706 declare -i t 707 _incT() { 708 t=$t+1 709 } 710 711 # Note: 712 # This is the same test used in the sparse array 713 #+ listing code fragment. 714 715 # Null reference, set: t == -1 716 t=${#VarNull}-1 # Results in minus-one. 717 ${VarNull+ _incT } # Does not execute. 718 echo $t' Null reference' 719 720 # Null contents, set: t == 0 721 t=${#VarEmpty}-1 # Results in minus-one. 722 ${VarEmpty+ _incT } # Executes. 723 echo $t' Null content' 724 725 # Contents, set: t == (number of non-null characters) 726 t=${#VarSomething}-1 # non-null length minus-one 727 ${VarSomething+ _incT } # Executes. 728 echo $t' Contents' 729 730 # Exercise: clean up that example. 731 unset t 732 unset _incT 733 734 # ${name?err_msg} ${name:?err_msg} 735 # These follow the same rules but always exit afterwards 736 #+ if an action is specified following the question mark. 737 # The action following the question mark may be a literal 738 #+ or a function result. 739 ### 740 # ${name?} ${name:?} are test-only, the return can be tested. 741 742 743 744 745 # Element operations 746 # ------------------ 747 748 echo 749 echo '- - Trailing sub-element selection - -' 750 751 # Strings, Arrays and Positional parameters 752 753 # Call this script with multiple arguments 754 #+ to see the parameter selections. 755 756 echo '- All -' 757 echo ${VarSomething:0} # all non-null characters 758 echo ${ArrayVar[@]:0} # all elements with content 759 echo ${@:0} # all parameters with content; 760 # ignoring parameter[0] 761 762 echo 763 echo '- All after -' 764 echo ${VarSomething:1} # all non-null after character[0] 765 echo ${ArrayVar[@]:1} # all after element[0] with content 766 echo ${@:2} # all after param[1] with content 767 768 echo 769 echo '- Range after -' 770 echo ${VarSomething:4:3} # ral 771 # Three characters after 772 # character[3] 773 774 echo '- Sparse array gotch -' 775 echo ${ArrayVar[@]:1:2} # four - The only element with content. 776 # Two elements after (if that many exist). 777 # the FIRST WITH CONTENTS 778 #+ (the FIRST WITH CONTENTS is being 779 #+ considered as if it 780 #+ were subscript zero). 781 # Executed as if Bash considers ONLY array elements with CONTENT 782 # printf %q "${ArrayVar[@]:0:3}" # Try this one 783 784 # In versions 2.04, 2.05a and 2.05b, 785 #+ Bash does not handle sparse arrays as expected using this notation. 786 # 787 # The current Bash maintainer, Chet Ramey, has corrected this 788 #+ for an upcoming version of Bash. 789 790 791 echo '- Non-sparse array -' 792 echo ${@:2:2} # Two parameters following parameter[1] 793 794 # New victims for string vector examples: 795 stringZ=abcABC123ABCabc 796 arrayZ=( abcabc ABCABC 123123 ABCABC abcabc ) 797 sparseZ=( [1]='abcabc' [3]='ABCABC' [4]='' [5]='123123' ) 798 799 echo 800 echo ' - - Victim string - -'$stringZ'- - ' 801 echo ' - - Victim array - -'${arrayZ[@]}'- - ' 802 echo ' - - Sparse array - -'${sparseZ[@]}'- - ' 803 echo ' - [0]==null ref, [2]==null ref, [4]==null content - ' 804 echo ' - [1]=abcabc [3]=ABCABC [5]=123123 - ' 805 echo ' - non-null-reference count: '${#sparseZ[@]}' elements' 806 807 echo 808 echo '- - Prefix sub-element removal - -' 809 echo '- - Glob-Pattern match must include the first character. - -' 810 echo '- - Glob-Pattern may be a literal or a function result. - -' 811 echo 812 813 814 # Function returning a simple, Literal, Glob-Pattern 815 _abc() { 816 echo -n 'abc' 817 } 818 819 echo '- Shortest prefix -' 820 echo ${stringZ#123} # Unchanged (not a prefix). 821 echo ${stringZ#$(_abc)} # ABC123ABCabc 822 echo ${arrayZ[@]#abc} # Applied to each element. 823 824 # Fixed by Chet Ramey for an upcoming version of Bash. 825 # echo ${sparseZ[@]#abc} # Version-2.05b core dumps. 826 827 # The -it would be nice- First-Subscript-Of 828 # echo ${#sparseZ[@]#*} # This is NOT valid Bash. 829 830 echo 831 echo '- Longest prefix -' 832 echo ${stringZ##1*3} # Unchanged (not a prefix) 833 echo ${stringZ##a*C} # abc 834 echo ${arrayZ[@]##a*c} # ABCABC 123123 ABCABC 835 836 # Fixed by Chet Ramey for an upcoming version of Bash 837 # echo ${sparseZ[@]##a*c} # Version-2.05b core dumps. 838 839 echo 840 echo '- - Suffix sub-element removal - -' 841 echo '- - Glob-Pattern match must include the last character. - -' 842 echo '- - Glob-Pattern may be a literal or a function result. - -' 843 echo 844 echo '- Shortest suffix -' 845 echo ${stringZ%1*3} # Unchanged (not a suffix). 846 echo ${stringZ%$(_abc)} # abcABC123ABC 847 echo ${arrayZ[@]%abc} # Applied to each element. 848 849 # Fixed by Chet Ramey for an upcoming version of Bash. 850 # echo ${sparseZ[@]%abc} # Version-2.05b core dumps. 851 852 # The -it would be nice- Last-Subscript-Of 853 # echo ${#sparseZ[@]%*} # This is NOT valid Bash. 854 855 echo 856 echo '- Longest suffix -' 857 echo ${stringZ%%1*3} # Unchanged (not a suffix) 858 echo ${stringZ%%b*c} # a 859 echo ${arrayZ[@]%%b*c} # a ABCABC 123123 ABCABC a 860 861 # Fixed by Chet Ramey for an upcoming version of Bash. 862 # echo ${sparseZ[@]%%b*c} # Version-2.05b core dumps. 863 864 echo 865 echo '- - Sub-element replacement - -' 866 echo '- - Sub-element at any location in string. - -' 867 echo '- - First specification is a Glob-Pattern - -' 868 echo '- - Glob-Pattern may be a literal or Glob-Pattern function result. - -' 869 echo '- - Second specification may be a literal or function result. - -' 870 echo '- - Second specification may be unspecified. Pronounce that' 871 echo ' as: Replace-With-Nothing (Delete) - -' 872 echo 873 874 875 876 # Function returning a simple, Literal, Glob-Pattern 877 _123() { 878 echo -n '123' 879 } 880 881 echo '- Replace first occurrence -' 882 echo ${stringZ/$(_123)/999} # Changed (123 is a component). 883 echo ${stringZ/ABC/xyz} # xyzABC123ABCabc 884 echo ${arrayZ[@]/ABC/xyz} # Applied to each element. 885 echo ${sparseZ[@]/ABC/xyz} # Works as expected. 886 887 echo 888 echo '- Delete first occurrence -' 889 echo ${stringZ/$(_123)/} 890 echo ${stringZ/ABC/} 891 echo ${arrayZ[@]/ABC/} 892 echo ${sparseZ[@]/ABC/} 893 894 # The replacement need not be a literal, 895 #+ since the result of a function invocation is allowed. 896 # This is general to all forms of replacement. 897 echo 898 echo '- Replace first occurrence with Result-Of -' 899 echo ${stringZ/$(_123)/$(_simple)} # Works as expected. 900 echo ${arrayZ[@]/ca/$(_simple)} # Applied to each element. 901 echo ${sparseZ[@]/ca/$(_simple)} # Works as expected. 902 903 echo 904 echo '- Replace all occurrences -' 905 echo ${stringZ//[b2]/X} # X-out b's and 2's 906 echo ${stringZ//abc/xyz} # xyzABC123ABCxyz 907 echo ${arrayZ[@]//abc/xyz} # Applied to each element. 908 echo ${sparseZ[@]//abc/xyz} # Works as expected. 909 910 echo 911 echo '- Delete all occurrences -' 912 echo ${stringZ//[b2]/} 913 echo ${stringZ//abc/} 914 echo ${arrayZ[@]//abc/} 915 echo ${sparseZ[@]//abc/} 916 917 echo 918 echo '- - Prefix sub-element replacement - -' 919 echo '- - Match must include the first character. - -' 920 echo 921 922 echo '- Replace prefix occurrences -' 923 echo ${stringZ/#[b2]/X} # Unchanged (neither is a prefix). 924 echo ${stringZ/#$(_abc)/XYZ} # XYZABC123ABCabc 925 echo ${arrayZ[@]/#abc/XYZ} # Applied to each element. 926 echo ${sparseZ[@]/#abc/XYZ} # Works as expected. 927 928 echo 929 echo '- Delete prefix occurrences -' 930 echo ${stringZ/#[b2]/} 931 echo ${stringZ/#$(_abc)/} 932 echo ${arrayZ[@]/#abc/} 933 echo ${sparseZ[@]/#abc/} 934 935 echo 936 echo '- - Suffix sub-element replacement - -' 937 echo '- - Match must include the last character. - -' 938 echo 939 940 echo '- Replace suffix occurrences -' 941 echo ${stringZ/%[b2]/X} # Unchanged (neither is a suffix). 942 echo ${stringZ/%$(_abc)/XYZ} # abcABC123ABCXYZ 943 echo ${arrayZ[@]/%abc/XYZ} # Applied to each element. 944 echo ${sparseZ[@]/%abc/XYZ} # Works as expected. 945 946 echo 947 echo '- Delete suffix occurrences -' 948 echo ${stringZ/%[b2]/} 949 echo ${stringZ/%$(_abc)/} 950 echo ${arrayZ[@]/%abc/} 951 echo ${sparseZ[@]/%abc/} 952 953 echo 954 echo '- - Special cases of null Glob-Pattern - -' 955 echo 956 957 echo '- Prefix all -' 958 # null substring pattern means 'prefix' 959 echo ${stringZ/#/NEW} # NEWabcABC123ABCabc 960 echo ${arrayZ[@]/#/NEW} # Applied to each element. 961 echo ${sparseZ[@]/#/NEW} # Applied to null-content also. 962 # That seems reasonable. 963 964 echo 965 echo '- Suffix all -' 966 # null substring pattern means 'suffix' 967 echo ${stringZ/%/NEW} # abcABC123ABCabcNEW 968 echo ${arrayZ[@]/%/NEW} # Applied to each element. 969 echo ${sparseZ[@]/%/NEW} # Applied to null-content also. 970 # That seems reasonable. 971 972 echo 973 echo '- - Special case For-Each Glob-Pattern - -' 974 echo '- - - - This is a nice-to-have dream - - - -' 975 echo 976 977 _GenFunc() { 978 echo -n ${0} # Illustration only. 979 # Actually, that would be an arbitrary computation. 980 } 981 982 # All occurrences, matching the AnyThing pattern. 983 # Currently //*/ does not match null-content nor null-reference. 984 # /#/ and /%/ does match null-content but not null-reference. 985 echo ${sparseZ[@]//*/$(_GenFunc)} 986 987 988 # A possible syntax would be to make 989 #+ the parameter notation used within this construct mean: 990 # ${1} - The full element 991 # ${2} - The prefix, if any, to the matched sub-element 992 # ${3} - The matched sub-element 993 # ${4} - The suffix, if any, to the matched sub-element 994 # 995 # echo ${sparseZ[@]//*/$(_GenFunc ${3})} # Same as ${1} here. 996 # Perhaps it will be implemented in a future version of Bash. 997 998 999 exit 0 |