System User's Guide: Operating System and Devices

You can use libm functions (math functions typically found in the C programming language), within arithmetic expressions, such as $ value=$((sqrt(9))). More arithmetic operators are available, including the unary +, ++, --, and the ?: construct (for example, "x ? y : z"), as well as the , (comma) operator. Arithmetic bases are supported up to base 64. Floating point arithmetic is also supported. "typeset -E" (exponential) can be used to specify the number of significant digits and "typeset -F" (float) can be used to specify the number of decimal places for an arithmetic variable. The SECONDS variable now displays to the nearest hundredth of a second, rather than to the nearest second.

Compound variables are supported in ksh93. A compound variable allows a user to specify multiple values within a single variable name. The values are each assigned with a subscript variable, separated from the parent variable with a . (period). For example:

$ myvar=( x=1 y=2 ) 
$ print "${myvar.x}" 
1

Compound assignments are supported when initializing arrays, both for indexed arrays and associative arrays. The assignment values are placed in parentheses as shown in the following example:

$ numbers=( zero one two three ) 
$ print ${numbers[0]} ${numbers[3]} 
zero three   

The typeset command used with the -A flag allows you to specify associative arrays within ksh93. For example:

$ typeset -A teammates 
$ teammates=( [john]=smith [mary]=jones ) 
$ print ${teammates[mary]} 
jones

The typeset command used with the -n flag allows you to assign one variable name as a reference to another. In this way, modifying the value of a variable will in turn modify the value of the variable that is referenced. For example:

$ greeting="hello"
$ typeset -n welcome=greeting     # establishes the reference 	
$ welcome="hi there"     # overrides previous value 	
$ print $greeting 	
hi there   

The following parameter-expansion constructs are available in ksh93:

• ${!varname} is the name of the variable itself.
• ${!varname[@]} names the indexes for the varname array.
• ${param:offset} is a substring of param, starting at offset.
• ${param:offset:num} is a substring of param, starting at offset, for num number of characters.
• ${@:offset} indicates all positional parameters starting at offset.
• ${@:offset:num} indicates num positional parameters starting at offset.
• ${param/pattern/repl} evaluates to param, with the first occurrence of pattern replaced by repl.
• ${param//pattern/repl} evaluates to param, with every occurrence of pattern replaced by repl.
• ${param/#pattern/repl} if param begins with pattern, then param is replaced by repl.
• ${param/%pattern/repl} if param ends with pattern, then param is replaced by repl.

A discipline function is a function that is associated with a specific variable. This allows you to define and call a function every time that variable is referenced, set, or unset. These functions take the form of varname.function, where varname is the name of the variable and function is the discipline function. There are three predefined discipline functions: get, set, and unset.

• The varname.get function is invoked every time varname is referenced. If the special variable .sh.value is set within this function, then the value of varname is changed to this value. A simple example is the time of day:

  $ function time.get 
  > { 
  >     .sh.value=$(date +%r) 
  > } 
  $ print $time 
  09:15:58 AM 
  $ print $time    # it will change in a few seconds 
  09:16:04 AM
  

• The varname.set function is invoked every time varname is set. The .sh.value variable is given the value that was assigned. The value assigned to varname is the value of .sh.value when the function completes. For example:

  $ function adder.set 
  > { 
  >   let .sh.value="
  $ {.sh.value} + 1" 
  > } 
  $ adder=0 
  $ echo $adder 
  1 
  $ adder=$adder 
  $ echo $adder 
  2  
  

• The varname.unset function is executed every time varname is unset. The variable does not actually get unset unless it is unset within the function itself; otherwise it retains its value.

Within all discipline functions, the special variable .sh.name is set to the name of the variable, while .sh.subscript is set to the value of the variables subscript, if applicable.

Functions declared with the function myfunc format are executed in a separate function environment. Functions declared as myfunc() execute with the same environment as the parent shell.

Variables beginning with .sh. are reserved by the shell and have special meaning. See the description of Discipline Functions above for an explanation of .sh.name, .sh.value, and .sh.subscript. Also available is .sh.version, which represents the version of the shell.

Note: The variable ERRNO is no longer available.

Return values of commands in ksh93 are as follows:

• If the command to be executed is not found, the return value is set to 127.
• If the command to be executed is found, but not executable, the return value is 126.
• If the command is executed, but is terminated by a signal, the return value is 256 plus the signal number.

Special built-in commands are searched for first, followed by all functions (including those in FPATH directories), followed by other built-ins. Previously, all built-ins were searched before all functions, and FPATH functions were not searched until after everything in PATH.

The hist command allows you to display and edit the shells command history. In the ksh shell, the fc command was used. The fc command is now an alias to hist. Variables are HISTCMD, which increments once for each command executed in the shells current history, and HISTEDIT, which specifies which editor to use when using the hist command.

• The built-in command builtin has been added. The builtin command lists all available built-in commands.
• The printf command has been added as a built-in. This functions much as the printf() C library routine does. Refer to the printf command manual page.
• The disown built-in command has been added. disown blocks the shell from sending a SIGHUP to the specified command.
• The getconf command has been added as a built-in. It functions in the same way as the stand-alone command /usr/bin/getconf. Refer to the getconf command manual page.
• The read built-in command has two flags:
  • read -d {char} allows you to specify a character delimiter instead of the default newline.
  • read -t {seconds} allows you to specify a time limit in seconds after which the read command will time out. If read times out, it will return FALSE.
• The exec built-in command has two flags:
  • exec -a {name} {cmd} specifies that argument 0 of cmd be replaced with name.
  • exec -c {cmd} tells exec to clear the environment before executing cmd.
• The kill built-in command has two flags:
  • kill -n {signum} is used for specifying a signal number to send to a process, while kill -s {signame} is used to specify a signal name.
  • kill -l, with no arguments, lists all signal names but not their numbers.
• The whence built-in command has two flags.
  • The -a flag displays all matches, not just the first one found.
  • The -f flag tells whence not to search for any functions.
• An escape character sequence has been added for use by the print and echo commands. The Esc (Escape) key can be represented by the sequence \E.
• All regular built-in commands recognize the -? flag, which shows the syntax for the specified command.