# Arithmetic

So far all we've been able to do is create and name objects. Some of those objects have been numbers — naturally we would like to do calculations with those numbers.

In the last chapter we saw how to create built-in functions to tell eval_expr how to process arguments into a return value. We will now create four more builtins to perform the basic arithmetic operations.

ExpressionResult
(+ X Y) The sum of X and Y
(- X Y) The difference of X and Y
(* X Y) The product of X and Y
(/ X Y) The quotient of X and Y

In the definitions above, when we write "the sum of X and Y", what we really mean is "the sum of the values obtained by evaluating X and Y". Remember that eval_expr will evaluate all the arguments to a functions by default; this is usually what we want to happen, so from now on we will not explicitly state this where the intent is obvious.

#### Implementation

Once again almost all of our function consists of checking that the correct arguments were supplied. Finally the result is constructed by the call to make_int.

{
Atom a, b;

if (nilp(args) || nilp(cdr(args)) || !nilp(cdr(cdr(args))))
return Error_Args;

a = car(args);
b = car(cdr(args));

if (a.type != AtomType_Integer || b.type != AtomType_Integer)
return Error_Type;

*result = make_int(a.value.integer + b.value.integer);

return Error_OK;
}

The other three functions differ by only one character, so I will omit them here.

Finally we need to create bindings for our new functions in the initial environment:

env_set(env, make_sym("-"), make_builtin(builtin_subtract));
env_set(env, make_sym("*"), make_builtin(builtin_multiply));
env_set(env, make_sym("/"), make_builtin(builtin_divide));

#### Testing

We now have our very own LISP-style calculator.

> (+ 1 1)
2
> (define x (* 6 9))
X
> x
54
> (- x 12)
42

In the last expression above, note that X is a symbol, not an integer. We have to evaluate the arguments so that builtin_subtract can operate on the integer value bound to X and not the symbol X itself. Similarly the value bound to X is the integer result of evaluating the expression (* 6 9).