The execute statement allows a procedure to call a sequence of statements within the current procedure as a “mini-subroutine”.


This statement has two parameters:

program – is the text (source code) of the program you want to run.

parameters – is a list of parameters to be passed to the subroutine. This list is optional, you don’t have to pass any parameters if you don’t need to. See parameter( and setparameter for more information on accessing parameters within a subroutine.


This statement allows a program to build a “mini-procedure” on the fly, and then run that procedure as a subroutine. The text of the “mini-procedure” can be in a field, a variable, or constructed using a formula. You can use the if error statement (see Error Handling) to check for syntax errors in the mini-program. Run time errors (missing variable, type mismatch, etc.) are handled just as they would be for any other program. You cannot use the debugger (single step, etc.) on a mini-procedure. After the mini-procedure has finished the main program continues from the next statement, just like a subroutine (unless the mini-procedure contains a stop statement).

If there is a syntax error in the mini-program (misspelled command, unexpected formula operator, etc.) two special local variables will be created: ExecuteErrorStart and ExecuteErrorEnd. These two variables contain the numbers for the starting and ending position of the error (the number of characters from the start of the mini-program.) The procedure can also find out the exact error with the info(“error”) function.

The example below illustrates how the execute statement works, but is rather silly since the mini-program could simply have been included in the main program. The real power of this statement is the ability to generate the mini-program on the fly, in response to changing circumstances. You could even keep mini-programs in a database field, giving each record its own program!

local myProgram
    {if clipboard() beginswith "Error" }+
    {message clipboard() }+
    {endif }
execute myProgram

If you want to check the mini-program for syntax errors without running it, put a return at the beginning of the mini-program. The return statement will prevent the mini-program itself from executing. This example assumes that the mini-program is in a field called Source. If there is an error, it displays the error and selects the offending section of the program (this assumes that Source is being edited in a Text Editor Object.) The -4 compensates for the return statement and space.

execute "return "+Source
if error
   message "Mini-program contains an error: "+info("error")
   activeobjectaction "SetSelection",ExecuteErrorStart-4,ExecuteErrorEnd-4
   message "Mini-program is A-OK"


When you call a subroutine you can supply one or more parameters to be passed to the subroutine (each parameter must be separated by a comma). When using the execute statement the parameters are listed after the source code, like this:

execute source,parameter1,parameter2,parameter3, ... parameterN

Within the source code you can access the parameters with the parameter( function, or change the value of a parameter with the setparameter statement. This is especially useful for accessing the main program’s local variables within the “mini-procedure”. Normally the local variables in the main program cannot be accessed within the “mini-procedure”, but parameters provide a way to do this. Here is a super simple example that shows how a parameter can be accessed.

local x,y,z,xs
x=3 y=2 z=5
xs={message parameter(1)}
execute xs,x
execute xs,y
execute xs,z

(Of course this example is rather contrived – there is no reason to not simply use the message statement directly instead of using the execute statement.)

You can also use the setparameter statement to modify the value of a parameter passed to the mini-procedure.

Note: Another way to access local variables in the main program is to use the executelocal statement.

See Also


10.0UpdatedCarried over from Panorama 6.0 but now allows parameters to be passed to and from the subroutine using the param( function and setparameter statement.