class THaCutList

 Default constructor. No variable list is defined. Either define it
 later with SetList() or pass the list as an argument to Define().
 Allowing this constructor is not very safe ...

 Normal constructor. Create the main lists and set the variable list.

 Default destructor. Deletes all cuts and lists.

 Remove all cuts and all blocks

 Clear the results of all defined cuts

 Clear the results of the defined cuts in the named block

 Compile all cuts in the list.
 Since cuts are compiled when we Define() them, this routine typically only
 needs to be called when global variable pointers need to be updated.

 Define a new cut with given name in given block. If the block does not
 exist, it is created.  This is the normal way to define a cut since
 there is usually just one variable list.

 Cut names MUST be unique and cannot be empty. Quotes and whitespace are
 illegal in cut names; any other characters are allowed.

 Symbolic variables in expressions must only refer to variables defined
 in the variable list OR to previously defined cuts.

 It is possible to use cut names from one block in definitions for a
 different block. This should be done with care, however, since such
 "external" cuts are not necessarily updated with the same frequency
 as the current block, depending on the design of the application.

 A return value of 0 indicates success, negative numbers indicate error.

 Define a new cut with given name in given block with variables from
 given list.  See description of Define() above.

 Evaluate all tests in all blocks.  Because of possible dependences between
 blocks, each block is evaluated separately in the order in which the blocks
 were defined.

 Evaluate all cuts in the given list in the order in which they were defined.

 Evaluate all tests in the given block in the order in which they were defined.
 If no argument is given, the default block is evaluated.

 Read cut definitions from a file and create the cuts. If no filename is
 given, the file ./cutdef.dat is used.

 Lines starting with # or "//" are treated as comments.
 Blank lines and leading spaces are ignored.

 A valid cut definition consists of two fields, a cut name and the
 corresponding expression.  The fields are separated by whitespace.
 Comments following the cut expression are ignored.

 Block names can be set using "Block:" as the cut name (without quotes)
 followed by the name of the block.

 Cuts are defined via the Define() method; see the description of
 Define() for more details.  Examples:

 # This is a comment. Blank lines are ignored, so are leading spaces.

 xcut  x>1
 cut1  x+y<10

 Block: Target_cuts
 cut2  x<10 || x>20   // Comment goes here
 zcut  (z^2-2)>0      # This text is ignored

 A return value of 0 indicates success. Negative values indicate severe
 errors (e.g. file not found, read error).  Positive numbers indicate the
 number of unprocessable lines (e.g. illegal expression, bad cutname) for
 which no cuts were defined.

 If the print option is either "LINE" or "STATS", determine the widths
 of the text fields of all the cuts in the given list and append them
 to the print option.
 This is an internal utility function used by Print() and PrintBlock().

 Print all cuts in all blocks.
 For options see THaCut.Print(). The default mode is "LINE". The
 widths of the text fields are determined automatically.
 For "LINE" and "STATS", cuts are printed grouped in blocks.

 Print all cuts in the named block.

 Print the definition of a single cut

 Print header for Print() and PrintBlock().
 This is an internal function.

 Reset all cut and block counters to zero

 Return result of the last evaluation of the named cut
 (0 if false, 1 if true).
 If cut does not exist, return -1. Also, print warning if mode=kWarn.

 Remove the named cut completely

 Remove all cuts contained in the named block.

 Set the pointer to the list of global variables to be used by default.
 Other variable lists can be used for individual cut definitions.