A small RPL scripting language

In every good program, a solid script language is provided. For example, in Office, Visual Basic For Application is used to allow easy programmation. And I needed a good language to automate the WinBSC program. So I started a small interpreter to analyse small arithmetic expressions, manage variables and so on.

The trend in scripting is to provide a ActiveX scripting language so that you can insert it in your project, if this one has a COM server. Your application must have a COM automation server so that the scripting language could access to program’s variable.

As the WinBSC program have no COM server, my server needn’t COM interface. So I did a interpreter which is quiet as complete as VBA but cannot access to COM object.

This interpreter has a syntax close to a “C” program. You can easily add the code in your program and add variables names that are comes from your program so that in the script namespace some variable of your program are visibles.

This scripting language is freely inspired by the C-language syntax and HP’s RPL in the way of manipulating variables :

• There are no variable declaration, but the first use of a new variable name must be a write (no read allowed on a undefined name).
  You can considere that the declaration is included in this first write. I find this way to do the declaration good to avoid use of uninitialised variable.
• Control structures must have the prefix #. This language syntax isn’t very beautiful but I found it cleared the code.
• Functions exists through file separation : one file, one function. The behavior is the same as Matlab .M files.
• A variable isn’t type constant. This allows a variable name to change of type. Actually, 5 types can be used, but the structure of the program allows an easy add of new types :

The id number is the value returned by the type() function. So you can test the type of a variable in a list, as you can put anything in it.

In the description below, I will use these notations for specifiing types of variable

The array element operator allows you to acceed directly to the elements of an array or a list. For an array, there should be as many operators as the dimension of the array. There are no check about the validity of a write in a matrix, so you could set a part of the matrix with vector of different size, so take care.

These variables are assigned with default value at the beginning of execution of the script, but can be changed by user.

All of the control structures are preceded by the #symbol to give the code more readability.

There are no function declaration in this style of script. But you can structurate your program in creating many files. Each files is a function. Then in a script, you can call another files with the call function, which works as descripted below.

With this behavior you can easily make big program. Recursion works also.

The script below solves a famous chess problem : the 8-queens problem. You use it in a command line windows. The interpreter is an executable called “script.exe”. So you execute a script this way :

script name_of_script { arguments }

The parameters in brackets are optionals.

So you use the script below called queens.rpl this way :

script queens.rpl 8

The 8 is the size of the chess board. The way we retrieve this argument is explained in the code.

/* Solving the queen problem on a n-by-n chess board
What's the problem :
When you have a n-by-n chess board, place n queens on it,
so that none of the queen can take another one.
With the dimension of the board, there are several solutions :
dim : 1 2 3 4  5 6  7  8   9  10   11    12 ...
sol : 1 0 0 2 10 4 10 92 352 724 2680 14200 ...
sec :                        524 
This program solves this problem with a backtracing algorithm.
*/
 
// retrieve arguments
// in arg variable is stored the list of arguments
// first check if there are some
#if(size(arg)==0);
  "usage reines.rpl size_of_board_as_int";
  #exit;
#end;
 
// check the argument is an integer
#if(type(arg[1])!=1);
  "usage reines.rpl size_of_board_as_int";
  #exit;
#end;
 
// size of the chess board
ordre = arg[1];
start = time();
ordre+" by "+ordre+" chess board solutions are :";
 
// private vars initialisation
sol = array(ordre); // sol is an array
fin = false;
nbs = 0;
i   = 0;
#while(!fin);
   i = i + 1;
   #while( (i<=ordre) && (!fin) );
      tst = false;
      #while( (sol[i]<ordre) && (!tst) );
         sol[i] = sol[i] + real(1);
	 // checking that queen j can't take preceding ones 
         tst = true;
         j = 1;
	 #while( (j<i) && (tst) );
	    #if( (sol[i]==sol[j]) ||  (abs(int(sol[i]-sol[j]))==(i-j)) );               
                tst = false;
	    #end;
	    j = j + 1;
         #end;
      #end;
      #if(!tst);
         sol[i] = 0;
         i = i - 1;
         #if(i==0);
            fin = true;
	 #else;
	    i = i - 1;
         #end;
      #end;
      i = i + 1;
   #end;
   #if(!fin);
      sol;
      nbs = nbs + 1;
      sol[ordre] = 0;
      i = ordre - 2;
   #end;
#end;
"There are "+nbs+" solutions";
"Time elapsed "+(time()-start)+" second(s)";

Thi script illustrated the way of calling another script. In fact, it calls himself recursively. It is the euclidean algorithm for pgcd calculus and returns the pgcd of the given 2 numbers.

Use it with this command line

script pgcd.rpl number1 number2

The script

// calculating the pgcd of two numbers
// with the recursive euclidean algorithm
// check that there are two arguments
#if(size(arg)!=2);
  "bad number of arguments";
  #exit();
#end;
a = arg[1];
b = arg[2];

// check the type
#if( (type(a)!=1) && (type(b)!=1) );
  "bad type of arguments";
  #exit();
#end;

// the algorithm
#if(b==0);
  #return(a);
#else;
  #return(call("pgcd.rpl", b, mod(a, b)));
#end;

I used this little script to bench my interpreter. It times a one million loop and the calling procedure. You can with these results appreciate the speed, although you can accerately times every functions.

// benchmarking of the interpreter
tstart = time();
i = 0;
#while(i<1000000);
  i = i + 1;
#end;
(time()-tstart)+" s";

tstart = time();
lst = list();
i = 0;
#while(i<1000);
  i = i + 1;
  a = int(1000000*rand());
  b = int(1000000*rand());
  lst = lst + { a b call("pgcd.rpl", a, b) };
#end;
(time()-tstart)+" s";

The results for a Pentium II 300 running NT40 Workstation + SP3 are :

• 12 s for the first script
• 27 s for the second script

Version 1.02, The interpreter (executable and source code) and some examples of scripts : script102.zip