# ic(1)

```
```

## NAME

```     ic - integer calculator

```

## SYNOPSIS

```     ic [expression]

```

## EXAMPLES

```
ic                  # Start the calculator

ic 250 300+         # Start calculator with 550 on the stack

```

## DESCRIPTION

```
Ic is a simple RPN (Reverse Polish Notation) calculator, used  for  small
calculations and base conversions. All calculations are done using 32 bit
integers.  The standard input is usually  a  keyboard  and  the  standard
output  requires  a device with a 'termcap' entry.  The program starts by
interpreting  any  <args>  as  commands,  where  the  separation  between
arguments is considered to be the same as the ENTER key. For example,

ic 692 784+

After reading the arguments input is from the keyboard.

Stack Operations

The operation of this program is similar to an  RPN  calculator.   A  six
level  stack  is  used.  The ENTER key pushes the stack up one level. For
example, '12+5' is entered as '12 ENTER 5 +".

The top two entries on the stack are exchanged by the x command, and  the
stack is rolled down one (popped) by the p key.  The top of the stack may
be cleared by pressing the  back-space  key.  The  whole  stack  and  the
registers are initialized by a z.

Numeric Entry

The input and output bases are initially decimal, but they may be changed
using  the  i and o commands. The i command changes both bases, but the o
command changes  just  the  output  base.   These  commands  take  a  one
character  argument  of  h,  d, o or b to change to Hexadecimal, Decimal,
Octal or Binary. While the  input  base  is  hexadecimal  the  letters  a
through f are used to represent the decimal values 10 through 15.

When the input base  is  decimal:  multiply,  divide  and  remainder  are
signed, otherwise they are performed unsigned.

The output base may also be changed to ASCII (a), this causes  the  least
significant 7 bits of a value to be displayed as a character. To input an
ASCII value the translate  (t)  command  may  be  used,  it  accepts  one
character as its argument.

Calculations

The  arithmetic  operations  supported  are:  Negate  ('.'),  Add  ('+'),
Subtract  ('-'),  Multiply ('*'), Divide ('/'), and Remainder ('%').  The
logical (Boolean) operations available are:  NOT  ('~'),  AND  ('&'),  OR
('|'), and EXCLUSIVE-OR ('^').

After one of these operations the last top of stack value  is  saved.  It
may be restored by pressing l (L).

Saving Results

Ten temporary registers are available. The Store (s) command followed  by
a  digit  ('0'..'9')  will  copy  the  top  of the stack to the specified
register. The Recall (r) command pushes the contents of a  register  onto
the top of the stack.

If the Store command is followed by a '+' preceding the digit,  then  the
top of the stack will be added to the specified 'accumulator' register.

Values may also be written to a file. The w command writes the top of the
stack,  using  the  current  output  base,  to a file called 'pad' in the
current directory.  If the user does not have write access to the current
directory  then  the  file /tmp/pad_\$USER is used as the scratch pad. The
scratch pad file is erased on the first use of the w command within  each
new invocation of 'ic'.

Miscellaneous

The Quit (q) key causes an immediate  exit.  The  m  command  temporarily
leaves  ic  by invoking the shell as a sub-process.  For help while using
ic, hit the h key. If an erroneous key is pressed the bell will sound.

Command Summary

Note that many commands have an alternative  key-code  available  on  the
extended  AT  keyboard. This aids entry by including most commands on the
right side of the keyboard.

ENTER          Enter (push up)
BS (DEL)       Clear top of stack
h              Help
i              Input base  (h, d, o, b)
l  (PGDN)      Last top of stack
m              MINIX shell
o              Output base (h, d, o, b, a)
p  (DOWN)      Pop stack (roll down)
q  (END)       Quit
r  (LEFT)      Recall (0-9)
s  (RIGHT)     Store [+] (0-9)
t              Translate (char)
w  (PGUP)      Write top of stack to scratch pad
x  (UP)        Exchange top of stack
z  (HOME)      Zero all state
.              Change sign
-  (-)         Subtract
*              Multiply
/              Divide
%  (sh/5)      Remainder
(tilde)        Not
&              And
|              Or
^              Exclusive-or

Author

Ic was written by Terrence W. Holm.

```