Prev: design-concepts.html  Up Next: help.html
Program invocation

Commandline arguments
To run the progam, say at your shell prompt:
blop [options] [files]
Possible options:
-x cmd
Execute the command 'cmd'
-s variable=value
Create a global variable called 'variable', and set its value to 'value. Equivalent to -x 'var variable="value";'
-w filename
The given file's status will be continuosly watched, and if it changes, the whole command will be rerun. This file will also be taken as a c++ script file to be executed. For example, the command 'blop -w file.C' will execute 'file.C' whenever it changes
-W filename
As -w filename, but the given file will not be taken as a c++ script (useful to monitor the change of datafiles) For example the command 'blop -W data.dat script.C' will execute the script 'script.C' whenever the datafile data.dat changes
Print version info (date of the last cvs commit)
-h topic
--help topic
Display help about topic
This argument is only useful when standard input is redirected. In this case blop is by default in script mode (see below... the input read from the standard input is interpreted as a script file, that is, it can contain function definitions, and it must contain a main function). The -m argument (with redirected input) causes blop to switch to the interactive mode, when any input is interpreted as if it was already within a main() { } function
Check if there is a more recent version available. If yes, download, compile and install it (via sudo)
If your code is very heavy, or CINT fails to interpret it (which is often the case with long chained member functions, for example plot("datafile").ds(cboxes().dx(1).dy(1).title("title").logscale(true));), then you may want to compile your code.

With -c or --compile blop will compile and run the given file. If blop.h is not included in your source, blop automatically creates a wrapper source file, something like this:

#include "blop.h"
using namespace blop;
#include "/your/home/directory/.blop/bloprc.C" // if it #exists
// some code here to run your BLOP_USER_INIT() function from bloprc.C
#include "your_script_file.C"
The -s and -x command-line arguments do not work in this case.
Any other command line arguments are interpreted as filenames, which must be valid C++ scripts. The interpreter will look for the function int main() {...} in these files, and run that function. If no filenames are given, or none of them contains the main function, the interpreter will run interactively, and further commands (which may call the functions provided in these files) are expected from the terminal.

The -x option can be used to communicate parameters to your scripts from the command line. For example:

 //  ------ test.C int
main() {
   cout<<"This  is  the  parameter: "<<par<<endl;  }
This script would not run without errors, because the variable par is not defined. But you can define it from the command line:
  [host] ~/  > blop -x  'var par="Hello  world";' test.C
or easier:
 [host]  ~/  > blop  -s par="Hello  world"

Running modes
There are 2 different modes of blop:
Script mode
If blop is given a C++ script file, it is in script mode: the file can contain function declarations/definitions, or anything that a valid C++ file can contain. It also MUST contain a main(){..} function, which will be executed.
By default, if no scriptfiles are provided on the command line, but standard input is redirected, blop is also in script mode (unless the -m option is given)
Interactive mode
If no scriptfiles are provided on the command line, and the standard input is not redirected, blop is in interactive mode: it expects commands from the terminal. These commands are interpreted as if they were already within the main(){..} function.

Initialization files
Upon startup, blop first loads the system-wide initialization file init.C from its installation directory (which is by default /usr/local/blop, unless changed during the installation). Then it will look for the file $HOME/.blop/bloprc.C. If this file exists, this will also be loaded before reading any other files. The user may provide handy functions in this file, which can be called later. If the user provides a function void BLOP_USER_INIT(); in this file, this will be called automatically at this point; this function can be used to set default values, or make any initializations. After this all remaining files provided as command line arguments are processed.

User include files
The directory $HOME/.blop/ is the place, where frequently used include-files should be placed. This directory is automatically included into the search path, where blop looks for files, when it finds a
#include "filename.h"

statement. (The bloprc.C file is also located in this directory)

When looking for help on a specific topic, say at your blop prompt: help("topic"); (where "topic" should of course be replaced by what you are looking for. It can be a regular expression as well.). This command will browse the documentation, and provide you a choice of different sections, which contain your keyword. (Currently you might get too many choices, since this command looks for all files in the documentation, which contain your keyword. This will improve in the future, and specific files will be preferred for certain keywords). The help system is HTML-based, the HTML browser to be used is figured out automatically, unless you set the environment variable BLOP_HELPVIEWER to some program. The pattern '%f' is replaced by the filename in this string. Example:

bash> export BLOP_HELPVIEWER="lynx %f"
bash> blop

You often find yourself not running blop interactively, but instead, writing a script. Thus, you do not have any running blop process, but you would like to look for help. It is painful to start a blop process, type help("something"); and then terminate the process, etc. Therefore the command line option -h is reserved to make your life easier: saying
blop -h topic
will do this job for your.

Prev: design-concepts.html  Up Next: help.html