Bernese GPS Software Version 5.0 - Bernese GNSS Software

19. Bernese Processing Engine (BPE)
delivered with the software. Most of them are very generic and may be used in a number
of different BPEs. The user may take them as examples for the development of his own
sophisticated user scripts when creating his own BPE procedures.
These scripts are started by the BPE-client and are responsible for running the main Bernese
programs or performing other specific tasks such as copying or downloading files or executing
auxiliary programs. On UNIX platforms the user scripts may be written in almost any
programming language (actually the only requirement is that the environment variables are
accessible from within the user script and some system commands can be performed). Old
UNIX user scripts were, e.g., written in Bourne shell and may still be used (with a few
modifications, see Section 24.3).
However, we recommend to use Perl for writing new scripts. Scripts written in Perl may
profit from inherited methods defined in the BPE client ${BPE}/RUNBPE.pm and efficiency
is increased because the user scripts do no need to be executed as a separate child process
of the client. On Windows platforms the use of Perl as scripting language is required. DOS
batch files are no longer supported. The “skeleton” of Perl user scripts is very simple as
shown in the following section.
19.6.1 User Script Skeleton
From the user point of view the most important method of the RUNBPE object (that is
defined in ${BPE}/RUNBPE.pm) is the method run. This method is responsible for starting
the user script. In the terminology of object-oriented programming the method should be
looked at as virtual. Therefore, it is possible to use the technique of method overloading. A
user script written in Perl inherits its behavior from the RUNBPE object and overrides the
RUNBPE::run method in such a way that it directly fulfills the required task.
Let us start with a trivial example of a user script. We call this script DUMMY and it does
nothing else but directly exiting. The implementation of the script is given here (of course,
the line numbers are not a part of the script):
1: package DUMMY;
2: @ISA = ("RUNBPE");
3: sub run {
4: my $bpe = shift;
5:
6: }
The first line is the name of the script. The second line says that the behavior of the new
package DUMMY (or object DUMMY) is inherited from the package RUNBPE. Lines 3–6
redefine the method run. In Perl object-oriented style the first parameter of each method is
the pointer to the object itself. Line 4 stores this pointer into the variable $bpe (using the
name $bpe is a useful convention but not a strict demand). The body of the script doing
the actual work would be specified in lines 5 and following.
Of course, real scripts will have to perform more complicated tasks (e.g., running a Bernese
program). However, the lines 1–4 from the example above may remain without any changes.
Before we proceed with a more sophisticated example we have to make a remark concerning
the variables that are accessible in user scripts.
Page 396 AIUB