Softpanorama
May the source be with you, but remember the KISS principle ;-)

Contents Bulletin Scripting in shell and Perl Network troubleshooting History Humor

Arithmetic Expressions in BASH

News

See also

Recommended  Links

Arithmetic expressions Double square bracket conditionals Single sqare bracket conditionals
Compound comparisons Integer comparison operators String comparison operators File test operators Quoting caveats Macro substitutions caveats
if statements in shell Loops in Shell Case statement in shell Shell History Humor Etc

Older UNIX shells like Borne shell  and ksh88 have clumsy, inefficient way of doing arithmetic based on external expr command:

z=`expr $z + 3` 

When Perl arrived, it became clear that such approach is inferior on modern computers and actually increases overhead of shell instead of decreasing it. So ksh93 was created to fight back the lost ground. While it failed to stop Perl, ksh93 was a big improvement, and later bash (starting from version 3.2) re-implemented most of the advanced features of ksh93 plus a couple of its own.  Currently bash is restricted to integer arithmetic while ksh93 can do floating-point arithmetic as well.

In bash version 3.2 and later you can (and should) use $(( )) or let for integer arithmetic expressions and conditionals. The idea of ((...)) construct is similar to [[...]] construct  introduced in ksh88. It provides built in capabilities for arithmetic that are superior to calling external function expr (or test in case of conditionals).

The ((...)) conditional expression evaluates an arithmetic expression like it was written in a "normal" algorithmic language (you can even omit dollar signs from the variables) and sets the exit status to 1 if the expression evaluates to 0, or to 0 if the expression evaluates to a non-zero value.  For example:

(( uid == 0 ))
(( uid > 1000 ))

You can use multiple expressions connected with operations AND or OR. That make it the new standard was to program integer comparisons in if statements, while loops and similar control flow constructs. Old [[...]] construct should no longer be used: it just does not make any sense anymore outside string comparisons.  For example

 (( percent >= 0 && percent 	<= 100 ))

Another  example:

 (( uid > 10  &&  uid < 100  )) # arithmetic condition

As long as you can limit yourself to integer arithmetic, you can use all the standard C-language operators inside of  ((...)) conditionals. Here is a more complex examples, that demonstrates that not always we can get rid of leasing $ in arithmetic expressions:

function mess
{
   if (( "$1" > 0 )) ; then
      total=$1
   else
      total=100
   fi
   tail -$total /var/adm/messages | more
}

All arithmetical operations are performed  on integers. For example:

	i=$(( i + 1 ))
	let i+=1

or

	i=$(( i++))
	let i++

In case of assignments, there must be no spaces around the equals sign. Generally in shells line bash or ksh93 spaces are treated as in any normal algorithmic language: they are optional.  Not not in this case and that a gotcha that you need to be aware of: a space before equal sign confuses bash into thinking that this is a function invocation. For example, in case of

	i = $(( i + 5 )) # not what you think!

bash will try to run a program named i and its first argument would be an equal sign, and its second argument would be the number you get adding 5 to the value of $i.

Another idiosyncrasy is that so called  R-value rule ($ should be prefixed to the shell variable on the right side of assignment statement to get its value) is optional and generally you should never use $ prefix for variables in ((..)) construct.  That means that

let i=$i+1

should be written as in regular programming languages:

let i=i+1 

The gotcha is that you still need the dollar sign for positional parameters (e.g.,$2) to distinguish it from a numeric constant (e.g., "2"). Here's an example:

i=$(( i + $2 ))

There is a several C-style shortcuts supported by BASH. The most useful is probably  +=  (familiar to any programmer). That means that:

let i=$i+5

can be written as

let i+=5
Usual C-style increments/decrements  ++/--  are available  too:
let $i++
or
(( $i++ ))

Shortcuts for assignment operators in bash

Operator Operation with assignment Use Meaning
= Simple assignment a=b a=b
*= Multiplication a*=b a=(a*b)
/= Division a/=b a=(a/b)
%= Remainder a%=b a=(a%b)
+= Addition a+=b a=(a+b)
-= Subtraction a-=b a=(a-b)
<<= Bit-shift left a<<=b a=(a<<b)
>>= Bit-shift right a>>=b a=(a>>b)
&= Bitwise "and" a&=b a=(a&b)
^= Bitwise "exclusive or" a^=b a=(a^b)
|= Bitwise "or" a|=b a=(a|b)

The assignments can  be cascaded, through the use of the comma operator:

	echo $(( i+=2 , j++ ))

which will do both assignments and then echo the result of the second expression (since the comma operator returns the value of its second expression).

Quotes or backslashes  usually are not needed  inside of the $(( )) construct:
all characters between the (( and )) are treated as string in double quotes.

The differences between the ((...)) command and let command

While constructs are almost identical there some minor differences. I would prefer to use ((..)) in both conditional expressions  and assignment statements as let construct contains a couple of unpleasant gotchas:

let i+=5
All-in-all despite warts this is a considerable improvement over what we used to have and newer versions of bash should be used whenever possible.  I would like to remind again that before ksh93 introduced let and (( ... )) commands, the only way to perform arithmetic was with expr. For example, to do the same increment to variable i you need to write:
i=`expr $i + 5` 
The ((...)) construct can (and should) be used in any control statements such as if, headers of loop and case statement. for example:
function mess
{
   if (( "$1" > 0 )) ; then
      total=$1
   else
      total=100
   fi
   tail -$total /var/adm/messages | more
}
Here are some additional examples (Internal Commands and Builtins)
Letting let do arithmetic.
#!/bin/bash

echo

let a=11            # Same as 'a=11'
let a=a+5           # Equivalent to  let "a = a + 5"
                    # (Double quotes and spaces make it more readable.)
echo "11 + 5 = $a"  # 16

let "a <<= 3"       # Equivalent to  let "a = a << 3"
echo "\"\$a\" (=16) left-shifted 3 places = $a"
                    # 128

let "a /= 4"        # Equivalent to  let "a = a / 4"
echo "128 / 4 = $a" # 32

let "a -= 5"        # Equivalent to  let "a = a - 5"
echo "32 - 5 = $a"  # 27

let "a *=  10"      # Equivalent to  let "a = a * 10"
echo "27 * 10 = $a" # 270

let "a %= 8"        # Equivalent to  let "a = a % 8"
echo "270 modulo 8 = $a  (270 / 8 = 33, remainder $a)"
                    # 6


# Does "let" permit C-style operators?
# Yes, just as the (( ... )) double-parentheses construct does.

let a++             # C-style (post) increment.
echo "6++ = $a"     # 6++ = 7
let a--             # C-style decrement.
echo "7-- = $a"     # 7-- = 6
# Of course, ++a, etc., also allowed . . .
echo


# Trinary operator.

# Note that $a is 6, see above.
let "t = a<7?7:11"   # True
echo $t  # 7

let a++
let "t = a<7?7:11"   # False
echo $t  #     11

exit

Using Array Variables

Bash, at last, provides one-dimensional indexed and associative array variables. They can be declared implicitly (contextually) or explicitly. To explicitly declare an array, use

     declare -a name

Initialization of arrays in bash has format similar to Perl:

	solaris=(serv01 serv02 serv07 ns1 ns2)

Each element of the array is a separate word in the list enclosed in parentheses. Then you can refer to each this way:

	echo solaris is installed on ${solaris[2]}

If you omit index writing  and use command "echo $solaris" you will get the first element too.

Another example taken from Bash Shell Programming in Linux
array=(red green blue yellow magenta)
size=${#array[*]}
echo "The array has $size members. They are:"
i=0
while [ $i -lt $size ]; do
	echo "$i: ${array[$i]}"
	let i++
done                          
Run this example:
$ ./myscript.sh
The array has 5 members. They are:
0: red
1: green
2: blue
3: yellow
4: magenta

The (( ...)) construct is also used in bash for a new form of  for loop syntax, one that looks a lot like C Language:

for (( i=1; 
i<=n; i++ )) 
do 
   touch file$i 
done 

for (( ; ; )) 
do 
   echo "infinite loop [ hit CTRL+C to stop]" 
done

Its more general form this new, C-like loop can be described as:

for (( expr1 ; expr2 ; expr3 )) ; do list ; done

The use of double parentheses indicates that expressions can use syntax of ((..)) construct.  several iteration counters can be used. For example:

	
for (( i=0, j=0 ; i < 10 ; i++, j++ ))
do
    echo $((i*j))
done

That for loop initializes two variables (i and j), then has a more complex second expression adding the two together before doing the less-than comparison. The comma operator is used again in the third expression to increment both variables.

Here are some additional examples from Advanced Bash scripting guide:

Example 10-12. A C-like for loop
for ((a=1; a <= LIMIT ; a++))  # Double parentheses, and "LIMIT" with no "$".
do
  echo -n "$a "
done                           # A construct borrowed from 'ksh93'.

echo; echo

# +=========================================================================+

# Let's use the C "comma operator" to increment two variables simultaneously.

for ((a=1, b=1; a <= LIMIT ; a++, b++))  # The comma chains together operations.
do
  echo -n "$a-$b "
done

echo; echo

exit 0

Top updates

Bulletin Latest Past week Past month
Google Search


NEWS CONTENTS

Old News ;-)

Please visit  Heiner Steven's SHELLdorado, the best shell scripting site on the Internet

[Nov 21, 2010] Integer Arithmetic

Both Bash and the Korn shell support evaluating arithmetic expressions without arithmetic expansion. The syntax is similar to $((...)) but without the dollar sign. Because expansion is not performed, the construct can be used without variable assignment or the colon operator:

$ x=10
$ ((x = x * 12))
$ echo $x
120
$

The real value of this construct is that it allows arithmetic expressions to be used rather than test in if, while, and until commands. The comparison operators set the exit status to a nonzero value if the result of the comparison is false and to a zero value if the result is true. So writing

(( i == 100 ))

has the effect of testing i to see whether it is equal to 100 and setting the exit status appropriately. This knowledge makes integer arithmetic ideal for inclusion in if commands:

if (( i == 100 ))
then
       ...
fi

The (( i == 100 )) returns an exit status of zero (true) if i equals 100 and one (false) otherwise, and has the same effect as writing

if [ "$i" -eq 100 ]
then
        ...
fi

One advantage of using ((...)) rather than test is the capability to perform arithmetic as part of the test:

if (( i / 10 != 0 ))
then
    ...
fi

Here the comparison returns a true if i divided by 10 is not equal to zero.

while loops can also benefit from integer arithmetic. For example,

x=0
while ((x++ < 100))
do
      commands
done

executes commands 100 times. (Note that some older versions of the Korn shell and Bash do not support the ++ and -- operators.)

Integer Types

The Korn shell and Bash both support an integer data type. You can declare variables to be integers by using the typeset command with the -i option

typeset -i variables

where variables are any valid shell variable names. Initial values can be assigned to the variables at the time they are declared.

Arithmetic performed on integer variables with the ((...)) construct is slightly faster than on noninteger ones because the shell internally stores the value of an integer variable as a binary number and not as a character string.

An integer variable cannot be assigned anything but an integer value or an integer expression. If you attempt to assign a noninteger to it, the message bad number is printed by the Korn shell:

$ typeset -i i
$ i=hello
ksh: i: bad number

Bash simply ignores any strings that don't contain numeric values and generates an error for anything that contains both numbers and other characters:

$ typeset -i i
$ i=hello
$ echo $i
0
$ i=1hello
bash: 1hello: value too great for base (error token is "1hello")
$ i=10+15
$ echo $i
25
$

The preceding example shows that integer-valued expressions can be assigned to an integer variable, without even having to use the ((...)) construct. This holds true for both Bash and the Korn shell.

Numbers in Different Bases

The Korn shell and Bash allow you to perform arithmetic in different bases. To write a number in a different base with these shells, you use the notation

base#number

For example, to express the value 100 in base 8 (octal) you write

8#100

You can write constants in different bases anywhere an integer value is permitted. To assign octal 100 to the integer variable i, you can write

typeset -i i=8#100

Note that with the Korn shell the base of the first value assigned to an integer variable fixes the base of all subsequent substitutions of that variable. In other words, if the first value you assign to the integer variable i is an octal number, each time you subsequently substitute the value of i on the command line, the Korn shell substitutes the value as an octal number using the notation 8#value.

$ typeset -i i=8#100
$ echo $i
8#100
$ i=50
$ echo $i
8#62
$ (( i = 16#a5 + 16#120 ))
$ echo $i
8#705

Because the first value assigned to i in this example is an octal number (8#100), all further substitutions of i will be in octal. When the base 10 value of 50 is next assigned to i and then i is subsequently displayed, we get the value 8#62, which is the octal equivalent of 50 in base 10.

In the preceding example, the ((...)) construct is used to add together the two hexadecimal values a5 and 120. The result is then displayed, once again in octal.

Bash uses both the base#number syntax for arbitrary bases and the C language syntax for octal and hexadecimal numbers—octal numbers are preceded by 0 (zero), and hexadecimal numbers are preceded by 0x:

$ typeset -i i=0100
$ echo $i
64
$ i=0x80
$ echo $i
128
$ i=2#1101001
$ echo $i
105
$ (( i = 16#a5 + 16#120 ))
$ echo $i
453
$

Unlike the Korn shell, Bash doesn't keep track of the variable's base; integer variables are displayed as decimal numbers. You can always use printf to print integers in octal or hexadecimal format.

[Nov 21, 2010] Advanced Bash Shell Scripting Guide - Operators

Arithmetic operators often occur in an expr or let expression.

Example 8-2. Using Arithmetic Operations

#!/bin/bash
# Counting to 11 in 10 different ways.

n=1; echo -n "$n "

let "n = $n + 1"   # let "n = n + 1"  also works.
echo -n "$n "


: $((n = $n + 1))
#  ":" necessary because otherwise Bash attempts
#+ to interpret "$((n = $n + 1))" as a command.
echo -n "$n "

(( n = n + 1 ))
#  A simpler alternative to the method above.
#  Thanks, David Lombard, for pointing this out.
echo -n "$n "

n=$(($n + 1))
echo -n "$n "

: $[ n = $n + 1 ]
#  ":" necessary because otherwise Bash attempts
#+ to interpret "$[ n = $n + 1 ]" as a command.
#  Works even if "n" was initialized as a string.
echo -n "$n "

n=$[ $n + 1 ]
#  Works even if "n" was initialized as a string.
#* Avoid this type of construct, since it is obsolete and nonportable.
#  Thanks, Stephane Chazelas.
echo -n "$n "

# Now for C-style increment operators.
# Thanks, Frank Wang, for pointing this out.

let "n++"          # let "++n"  also works.
echo -n "$n "

(( n++ ))          # (( ++n )  also works.
echo -n "$n "

: $(( n++ ))       # : $(( ++n )) also works.
echo -n "$n "

: $[ n++ ]         # : $[ ++n ]] also works
echo -n "$n "

echo

exit 0
Integer variables in Bash are actually signed long (32-bit) integers, in the range of -2147483648 to 2147483647. An operation that takes a variable outside these limits will give an erroneous result.
a=2147483646
echo "a = $a"      # a = 2147483646
let "a+=1"         # Increment "a".
echo "a = $a"      # a = 2147483647
let "a+=1"         # increment "a" again, past the limit.
echo "a = $a"      # a = -2147483648
                   #      ERROR (out of range)

As of version 2.05b, Bash supports 64-bit integers. Bash does not understand floating point arithmetic. It treats numbers containing a decimal point as strings.

a=1.5

let "b = $a + 1.3"  # Error.
# t2.sh: let: b = 1.5 + 1.3: syntax error in expression (error token is ".5 + 1.3")

echo "b = $b"       # b=1
Use bc in scripts that that need floating point calculations or math library functions.

[Jun 19, 2008] Bash Arrays  by Mitch Frazier

Linux Journal

If you're used to a "standard" *NIX shell you may not be familiar with bash's array feature. Although not as powerful as similar constructs in the P languages (Perl, Python, and PHP) and others, they are often quite useful.

Bash arrays have numbered indexes only, but they are sparse, ie you don't have to define all the indexes. An entire array can be assigned by enclosing the array items in parenthesis:

  arr=(Hello World)
Individual items can be assigned with the familiar array syntax (unless you're used to Basic or Fortran):
  arr[0]=Hello
  arr[1]=World
But it gets a bit ugly when you want to refer to an array item:
  echo ${arr[0]} ${arr[1]}
To quote from the man page:
The braces are required to avoid conflicts with pathname expansion.

In addition the following funky constructs are available:

  ${arr[*]}         # All of the items in the array
  ${!arr[*]}        # All of the indexes in the array
  ${#arr[*]}        # Number of items in the array
  ${#arr[0]}        # Length if item zero
The ${!arr[*]} is a relatively new addition to bash, it was not part of the original array implementation.

The following example shows some simple array usage (note the "[index]=value" assignment to assign a specific index):

#!/bin/bash

array=(one two three four [5]=five)

echo "Array size: ${#array[*]}"

echo "Array items:"
for item in ${array[*]}
do
    printf "   %s\n" $item
done

echo "Array indexes:"
for index in ${!array[*]}
do
    printf "   %d\n" $index
done

echo "Array items and indexes:"
for index in ${!array[*]}
do
    printf "%4d: %s\n" $index ${array[$index]}
done
Running it produces the following output:
Array size: 5
Array items:
   one
   two
   three
   four
   five
Array indexes:
   0
   1
   2
   3
   5
Array items and indexes:
   0: one
   1: two
   2: three
   3: four
   5: five

Note that the "@" sign can be used instead of the "*" in constructs such as ${arr[*]}, the result is the same except when expanding to the items of the array within a quoted string. In this case the behavior is the same as when expanding "$*" and "$@" within quoted strings: "${arr[*]}" returns all the items as a single word, whereas "${arr[@]}" returns each item as a separate word.

The following example shows how unquoted, quoted "*", and quoted "@" affect the expansion (particularly important when the array items themselves contain spaces):

#!/bin/bash

array=("first item" "second item" "third" "item")

echo "Number of items in original array: ${#array[*]}"
for ix in ${!array[*]}
do
    printf "   %s\n" "${array[$ix]}"
done
echo

arr=(${array[*]})
echo "After unquoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done
echo

arr=("${array[*]}")
echo "After * quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done
echo

arr=("${array[@]}")
echo "After @ quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
do
    printf "   %s\n" "${arr[$ix]}"
done
When run it outputs:
Number of items in original array: 4
   first item
   second item
   third
   item

After unquoted expansion: 6
   first
   item
   second
   item
   third
   item

After * quoted expansion: 1
   first item second item third item

After @ quoted expansion: 4
   first item
   second item
   third
   item

Mitch Frazier is the System Administrator at Linux Journal.

Arithmetic expansion with double parentheses, and using let 

The use of backticks (backquotes) in arithmetic expansion has been superseded by double parentheses -- ((...)) and $((...)) -- and also by the very convenient let construction.
z=$(($z+3))
z=$((z+3))                                  #  Also correct.
                                            #  Within double parentheses,
                                            #+ parameter dereferencing
                                            #+ is optional.

# $((EXPRESSION)) is arithmetic expansion.  #  Not to be confused with
                                            #+ command substitution.



# You may also use operations within double parentheses without assignment.

  n=0
  echo "n = $n"                             # n = 0

  (( n += 1 ))                              # Increment.
# (( $n += 1 )) is incorrect!
  echo "n = $n"                             # n = 1


let z=z+3
let "z += 3"  #  Quotes permit the use of spaces in variable assignment.
              #  The 'let' operator actually performs arithmetic evaluation,
              #+ rather than expansion.

Recommended Links

Softpanorama Top Visited

Softpanorama Recommended

Please visit  Heiner Steven SHELLdorado  the best shell scripting site on the Internet

Advanced Bash-Scripting Guide

Linux.com Turn Vim into a bash IDE

Debugging

Linux tip Bash test and comparison functions

Common shell script mistakes

Reference

Examples shipped with bash 3.2 and newer
Path Description X-ref
./bashdb 
Deprecated sample implementation of a bash debugger.  
./complete 
Shell completion code.  
./functions 
Example functions.  
./functions/array-stuff 
Various array functions (ashift, array_sort, reverse).  
./functions/array-to-string 
Convert an array to a string.  
./functions/autoload 
An almost ksh-compatible 'autoload' (no lazy load). ksh
./functions/autoload.v2 
An almost ksh-compatible 'autoload' (no lazy load). ksh
./functions/autoload.v3 
A more ksh-compatible 'autoload' (with lazy load). ksh
./functions/basename 
A replacement for basename(1). basename
./functions/basename2 
Fast basename(1) and dirname(1) functions for bash/sh. basename, dirname
./functions/coproc.bash 
Start, control, and end co-processes.  
./functions/coshell.bash 
Control shell co-processes (see coprocess.bash).  
./functions/coshell.README 
README for coshell and coproc.  
./functions/csh-compat 
A C-shell compatibility package. csh
./functions/dirfuncs 
Directory manipulation functions from the book The Korn Shell.  
./functions/dirname 
A replacement for dirname(1). dirname
./functions/emptydir 
Find out if a directory is empty.  
./functions/exitstat 
Display the exit status of processes.  
./functions/external 
Like command, but forces the use of external command.  
./functions/fact 
Recursive factorial function.  
./functions/fstty 
Front-end to sync TERM changes to both stty(1) and readline 'bind'. stty.bash
./functions/func 
Print out definitions for functions named by arguments.  
./functions/gethtml 
Get a web page from a remote server (wget(1) in bash).  
./functions/getoptx.bash 
getopt function that parses long-named options.  
./functions/inetaddr 
Internet address conversion (inet2hex and hex2inet).  
./functions/inpath 
Return zero if the argument is in the path and executable. inpath
./functions/isnum.bash 
Test user input on numeric or character value.  
./functions/isnum2 
Test user input on numeric values, with floating point.  
./functions/isvalidip 
Test user input for valid IP addresses.  
./functions/jdate.bash 
Julian date conversion.  
./functions/jj.bash 
Look for running jobs.  
./functions/keep 
Try to keep some programs in the foreground and running.  
./functions/ksh-cd 
ksh-like cd: cd [-LP] [dir[change]]. ksh
./functions/ksh-compat-test 
ksh-like arithmetic test replacements. ksh
./functions/kshenv 
Functions and aliases to provide the beginnings of a ksh environment for bash ksh
./functions/login 
Replace the login and newgrp built-ins in old Bourne shells.  
./functions/lowercase 
Rename files to lowercase. rename lower
./functions/manpage 
Find and print a manpage. fman
./functions/mhfold 
Print MH folders, useful only because folders(1) doesn't print mod date/times.  
./functions/notify.bash 
Notify when jobs change status.  
./functions/pathfuncs 
Path related functions (no_path, add_path, pre-path, del_path). path
./functions/README 
README  
./functions/recurse 
Recursive directory traverser.  
./functions/repeat2 
A clone of the C shell built-in repeat. repeat, csh
./functions/repeat3 
A clone of the C shell built-in repeat. repeat, csh
./functions/seq 
Generate a sequence from m to n;m defaults to 1.  
./functions/seq2 
Generate a sequence from m to n;m defaults to 1.  
./functions/shcat 
Readline-based pager. cat, readline pager
./functions/shcat2 
Readline-based pagers. cat, readline pager
./functions/sort-pos-params 
Sort the positional parameters.  
./functions/substr 
A function to emulate the ancient ksh built-in. ksh
./functions/substr2 
A function to emulate the ancient ksh built-in. ksh
./functions/term 
A shell function to set the terminal type interactively or not.  
./functions/whatis 
An implementation of the 10th Edition Unix sh built-in whatis(1) command.  
./functions/whence 
An almost ksh-compatible whence(1) command.  
./functions/which 
An emulation of which(1) as it appears in FreeBSD.  
./functions/xalias.bash 
Convert csh alias commands to bash functions. csh, aliasconv
./functions/xfind.bash 
A find(1) clone.  
./loadables/ 
Example loadable replacements.  
./loadables/basename.c 
Return nondirectory portion of pathname. basename
./loadables/cat.c 
cat(1) replacement with no options—the way cat was intended. cat, readline pager
./loadables/cut.c 
cut(1) replacement.  
./loadables/dirname.c 
Return directory portion of pathname. dirname
./loadables/finfo.c 
Print file info.  
./loadables/getconf.c 
POSIX.2 getconf utility.
./loadables/getconf.h 
Replacement definitions for ones the system doesn't provide.  
./loadables/head.c 
Copy first part of files.  
./loadables/hello.c 
Obligatory "Hello World" / sample loadable.  
./loadables/id.c 
POSIX.2 user identity.  
./loadables/ln.c 
Make links.  
./loadables/logname.c 
Print login name of current user.  
./loadables/Makefile.in 
Simple makefile for the sample loadable built-ins.  
./loadables/mkdir.c 
Make directories.  
./loadables/necho.c 
echo without options or argument interpretation.  
./loadables/pathchk.c 
Check pathnames for validity and portability.  
./loadables/print.c 
Loadable ksh-93 style print built-in.  
./loadables/printenv.c 
Minimal built-in clone of BSD printenv(1).  
./loadables/push.c 
Anyone remember TOPS-20?  
./loadables/README 
README  
./loadables/realpath.c 
Canonicalize pathnames, resolving symlinks.  
./loadables/rmdir.c 
Remove directory.  
./loadables/sleep.c 
Sleep for fractions of a second.  
./loadables/strftime.c 
Loadable built-in interface to strftime(3).  
./loadables/sync.c 
Sync the disks by forcing pending filesystem writes to complete.  
./loadables/tee.c 
Duplicate standard input.  
./loadables/template.c 
Example template for loadable built-in.  
./loadables/truefalse.c 
True and false built-ins.  
./loadables/tty.c 
Return terminal name.  
./loadables/uname.c 
Print system information.  
./loadables/unlink.c 
Remove a directory entry.  
./loadables/whoami.c 
Print out username of current user.  
./loadables/perl/ 
Illustrates how to build a Perl interpreter into bash.  
./misc 
Miscellaneous  
./misc/aliasconv.bash 
Convert csh aliases to bash aliases and functions. csh, xalias
./misc/aliasconv.sh 
Convert csh aliases to bash aliases and functions. csh, xalias
./misc/cshtobash 
Convert csh aliases, environment variables, and variables to bash equivalents. csh, xalias
./misc/README 
README  
./misc/suncmd.termcap 
SunView TERMCAP string.  
./obashdb 
Modified version of the Korn Shell debugger from Bill Rosenblatt's Learning the Korn Shell.
./scripts.noah 
Noah Friedman's collection of scripts (updated to bash v2 syntax by Chet Ramey).  
./scripts.noah/aref.bash 
Pseudo-arrays and substring indexing examples.  
./scripts.noah/bash.sub.bash 
Library functions used by require.bash.  
./scripts.noah/bash_version. bash 
A function to slice up $BASH_VERSION.  
./scripts.noah/meta.bash 
Enable and disable eight-bit readline input.  
./scripts.noah/mktmp.bash 
Make a temporary file with a unique name.  
./scripts.noah/number.bash 
A fun hack to translate numerals into English.  
./scripts.noah/PERMISSION 
Permissions to use the scripts in this directory.  
./scripts.noah/prompt.bash 
A way to set PS1 to some predefined strings.  
./scripts.noah/README 
README  
./scripts.noah/remap_keys.bash 
A front end to bind to redo readline bindings. readline
./scripts.noah/require.bash 
Lisp-like require/provide library functions for bash.  
./scripts.noah/send_mail. 
Replacement SMTP client written in bash.  
./scripts.noah/shcat.bash 
bash replacement for cat(1). cat
./scripts.noah/source.bash 
Replacement for source that uses current directory.  
./scripts.noah/string.bash 
The string(3) functions at the shell level.  
./scripts.noah/stty.bash 
Front-end to stty(1) that changes readline bindings too. fstty
./scripts.noah/y_or_n_p.bash 
Prompt for a yes/no/quit answer. ask
./scripts.v2 
John DuBois' ksh script collection (converted to bash v2 syntax by Chet Ramey).  
./scripts.v2/arc2tarz 
Convert an arc archive to a compressed tar archive.  
./scripts.v2/bashrand 
Random number generator with upper and lower bounds and optional seed. random
./scripts.v2/cal2day.bash 
Convert a day number to a name.  
./scripts.v2/cdhist.bash 
cd replacement with a directory stack added.  
./scripts.v2/corename 
Tell what produced a core file.  
./scripts.v2/fman 
Fast man(1) replacement. manpage
./scripts.v2/frcp 
Copy files using ftp(1) but with rcp-type command-line syntax.  
./scripts.v2/lowercase 
Change filenames to lowercase. rename lower
./scripts.v2/ncp 
A nicer front end for cp(1) (has -i, etc)..  
./scripts.v2/newext 
Change the extension of a group of files. rename
./scripts.v2/nmv 
A nicer front end for mv(1) (has -i, etc).. rename
./scripts.v2/pages 
Print specified pages from files.  
./scripts.v2/PERMISSION 
Permissions to use the scripts in this directory.  
./scripts.v2/pf 
A pager front end that handles compressed files.  
./scripts.v2/pmtop 
Poor man's top(1) for SunOS 4.x and BSD/OS.  
./scripts.v2/README 
README  
./scripts.v2/ren 
Rename files by changing parts of filenames that match a pattern. rename
./scripts.v2/rename 
Change the names of files that match a pattern. rename
./scripts.v2/repeat 
Execute a command multiple times. repeat
./scripts.v2/shprof 
Line profiler for bash scripts.  
./scripts.v2/untar 
Unarchive a (possibly compressed) tarfile into a directory.  
./scripts.v2/uudec 
Carefully uudecode(1) multiple files.  
./scripts.v2/uuenc 
uuencode(1) multiple files.  
./scripts.v2/vtree 
Print a visual display of a directory tree. tree
./scripts.v2/where 
Show where commands that match a pattern are.  
./scripts 
Example scripts.  
./scripts/adventure.sh 
Text adventure game in bash!  
./scripts/bcsh.sh 
Bourne shell's C shell emulator. csh
./scripts/cat.sh 
Readline-based pager. cat, readline pager
./scripts/center 
Center a group of lines.  
./scripts/dd-ex.sh 
Line editor using only /bin/sh, /bin/dd, and /bin/rm.  
./scripts/fixfiles.bash 
Recurse a tree and fix files containing various bad characters.  
./scripts/hanoi.bash 
The inevitable Towers of Hanoi in bash.  
./scripts/inpath 
Search $PATH for a file the same name as $1; return TRUE if found. inpath
./scripts/krand.bash 
Produces a random number within integer limits. random
./scripts/line-input.bash 
Line input routine for GNU Bourne Again Shell plus terminal-control primitives.  
./scripts/nohup.bash 
bash version of nohup command.  
./scripts/precedence 
Test relative precedences for && and || operators.  
./scripts/randomcard.bash 
Print a random card from a card deck. random
./scripts/README 
README  
./scripts/scrollbar 
Display scrolling text.  
./scripts/scrollbar2 
Display scrolling text.  
./scripts/self-repro 
A self-reproducing script (careful!).  
./scripts/showperm.bash 
Convert ls(1) symbolic permissions into octal mode.  
./scripts/shprompt 
Display a prompt and get an answer satisfying certain criteria. ask
./scripts/spin.bash 
Display a spinning wheel to show progress.  
./scripts/timeout 
Give rsh(1) a shorter timeout.  
./scripts/vtree2 
Display a tree printout of the direcotry with disk use in 1k blocks. tree
./scripts/vtree3 
Display a graphical tree printout of dir. tree
./scripts/vtree3a 
Display a graphical tree printout of dir. tree
./scripts/websrv.sh 
A web server in bash!  
./scripts/xterm_title 
Print the contents of the xterm title bar.  
./scripts/zprintf 
Emulate printf (obsolete since printf is now a bash built-in).  
./startup-files 
Example startup files.  
./startup-files/Bash_aliases 
Some useful aliases (written by Fox).  
./startup-files/Bash_profile 
Sample startup file for bash login shells (written by Fox).  
./startup-files/bash-profile 
Sample startup file for bash login shells (written by Ramey).  
./startup-files/bashrc 
Sample Bourne Again Shell init file (written by Ramey).  
./startup-files/Bashrc.bfox 
Sample Bourne Again Shell init file (written by Fox).  
./startup-files/README 
README  
./startup-files/apple 
Example startup files for Mac OS X.  
./startup-files/apple/aliases 
Sample aliases for Mac OS X.  
./startup-files/apple/bash.defaults 
Sample User preferences file.  
./startup-files/apple/environment 
Sample Bourne Again Shell environment file.  
./startup-files/apple/login 
Sample login wrapper.  
./startup-files/apple/logout 
Sample logout wrapper.  
./startup-files/apple/rc 
Sample Bourne Again Shell config file.  
./startup-files/apple/README 
README



Etc

Society

Groupthink : Understanding Micromanagers and Control Freaks : Toxic Managers : BureaucraciesHarvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Two Party System as Polyarchy : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy

Quotes

Skeptical Finance : John Kenneth Galbraith : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes : Oscar Wilde : Talleyrand : Somerset Maugham : War and Peace : Marcus Aurelius : Eric Hoffer : Kurt Vonnegut : Otto Von Bismarck : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce : Oscar Wilde : Bernard Shaw : Mark Twain Quotes

Bulletin:

Vol 26, No.1 (January, 2013) Object-Oriented Cult : Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks: The efficient markets hypothesis : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Vol 23, No.10 (October, 2011) An observation about corporate security departments : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law

History:

Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor

 

The Last but not Least


Copyright © 1996-2014 by Dr. Nikolai Bezroukov. www.softpanorama.org was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine. This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to make a contribution, supporting hosting of this site with different providers to distribute and speed up access. Currently there are two functional mirrors: softpanorama.info (the fastest) and softpanorama.net.

Disclaimer:

The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

Last modified: February, 19, 2014