Control structures

    ==> x := 1;
        for i := 2 to 100 do
            x := x*i;
        end;
        x.

The above for loop is equivalent to the following while loop

    ==> x := 1; i := 2;
        while i <= 100 do
            x := x*i;
            inc(i);
        end;
        x.

The branching construct
if ... then ... elsif ... else ... end
has also the same syntax as in Modula-2.

Multiprecision floating point arithmetic

        single_float    32 bits
        double_float    64 bits
        long_float     128 bits

The precision can be changed using the function set_floatprec. The function takes one integer argument, which is the desired precision in bits. It is automatically rounded to the next higher available value. For example, after

    ==> set_floatprec(100).
    -: 128

    ==> arctan(sqrt(3)).
    -: 1.04719_75511_96597_74615_42144_61093_16762_8
    ==> _/pi.
    -: 0.33333_33333_33333_33333_33333_33333_33333_33

User defined functions

    ==> function fac(n: integer): integer;
        var
            x,i: integer;
        begin
            x := 1;
            for i := 2 to n do
                x := x*i;
            end;
            return x;
        end.

    -: fac

    ==> fac(32).
    -: 2_63130_83693_36935_30167_21801_21600_00000
 

    ==> function sqrt_list(n: integer): array of real;
        var
            vec: array[n] of real;
            i: integer;
        begin
            for i := 1 to n do
                vec[i-1] := sqrt(i);
            end;
            return vec;
        end.

    ==> sqrt_list(10).
    -: (1.00000000, 1.41421356, 1.73205081, 2.00000000, 
    2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.00000000, 
    3.16227766)

    ==> load("abcd").

    
    error in line <= 23 of loaded file
    if: end expected

Online help

    ==> symbols(aribas).

(ARGV, _, __, ___, abs, alloc, and, arccos, arcsin, arctan, arctan2, aribas, array, atof, atoi, begin, binary, bit_and, bit_clear, bit_length, ...... , tolower, toupper, transcript, true, trunc, type, user, var, version, while, write, write_block, write_byte, writeln)

For most of the symbols in this list, you can get a short online help using the function help(). For example, the command

    ==> help(ARGV).

    ==> help(while).

How to exit

    ==> exit

If you don't want to leave aribas, but want to break out of an infinite loop or a calculation that lasts too long, type CONTROL-C (if you are running aribas from within Emacs, you must press CONTROL-C twice). This will (in most cases) stop the current calculation and return to the aribas prompt.

When you are not using the Emacs interface but the command line version of aribas, you sometimes get into the following situation: Some previous line contains a typing error, but you cannot return to that line to correct it. In this case you should simply type a full stop `.' , followed by RETURN. You will get an error message which you can safely ignore, and a new prompt ==> appears, allowing you to try again.

options

-q

(quiet mode) Suppresses all messages to the screen (version no, copyright notice, etc.) when aribas is started

-v

(verbose mode, default) Does not suppress messages to the screen when aribas is started.

-c <cols>

aribas does its own line breaking when writing to the screen. Normally it supposes that the screen (or the window in which aribas runs) has 80 columns. With the -c option you can set another number, which must be between 40 and 160 (in decimal representation). For example, if you run aribas in an Xterm window with 72 columns, use the option -c72 (or -c 72, the space between -c and the number is optional).

-m <mem>

Here <mem> is a number (in decimal representation) between 64 and 16000. This number indicates how many Kilobytes of RAM aribas should use for the aribas heap. The default value depends on the options used when aribas was compiled. Typically, under UNIX or LINUX it is 6 Megabytes, corresponding to -m6000

-h <path of help file>

The online help of aribas depends on a file aribas.hlp which should be situated in the range of the environment variable PATH. If this is not the case you can specify the exact path of the help file with the -h option. If for example the file aribas.hlp is in the directory /usr/local/lib, use the option -h /usr/local/lib (the space after -h is not necessary). The -h option can also be used if the help file has a different name. If the help file is named help-aribas and lies in the directory /home/joe/ari, use -h/home/joe/ari/help-aribas.

With a properly installed Debian package of aribas it should not be necessary to use this option.

-p <ari-search-path>

With this option you can specify a search path for loading files with aribas source code. <ari-search-path> may be either the (absolute) pathname of one directory or several pathnames separated by colons. Suppose that you have called aribas with the option

-p/usr/local/lib/aribas:~/ari/examples

and that your home directory is /home/alice/. Then the command

==> load("factor").

will search the file factor.ari first in the current directory, then in the directory /usr/local/lib/aribas and finally in /home/alice/ari/examples.

-b

Batch mode when loading an aribas source code file from the command line, see below.

One letter options which require no arguments may be merged, for example

aribas -q -b

is equivalent to

aribas -qb

Further command line arguments

<ari-file>

The next command line argument after the options is interpreted as the name of a file with aribas source code. If the file name has the extension .ari, this extension may be omitted. The file is loaded as if the command load("<ari-file>") had been given after the start of aribas at the aribas prompt. If the file is not found in the current directory it is searched in the directories specified by the -p option. If the option -b was given, the file is loaded and executed. Afterwards aribas exits without showing it's prompt. If the file cannot be loaded completely because of an error, aribas exits immediately after the error message.

<arg1> <arg2> ...

When further command line arguments follow <ari-file>, they are collected (as strings) together with <ari-file> in the vector ARGV which can be accessed from within aribas. Example: If you call aribas with the command line

aribas startup 4536 eisenstein

and the current directory contains the file startup.ari, then aribas loads it and the vector ARGV has the form

    ==> ARGV.
    -: ("startup", "4536", "eisenstein")
    

If you need some arguments as numbers and not as strings, you can transform them by atoi (or atof); in our example

    ==> x := atoi(ARGV[1]).
    -: 4536
    

will do it. The length of the vector ARGV can be determined by length(ARGV).