The ti(try)-block surrounds tt(throw) statements. Remember that a program is
always surrounded by a global tt(try) block, so tt(throw) statements may
appear anywhere in your code. More often, though, tt(throw) statements are
used in function bodies and such functions may be called from within tt(try)
blocks.

A tt(try) block is defined by the keyword tt(try) followed by a compound
statement. This block, in turn,  em(must) be followed by at least one
tt(catch) handler:
        verb(    try
    {
                // any statements here
    }
    catch(...)  // at least one catch clause here
    {})

tt(Try)-blocks are commonly nested, creating exception em(levels). For
example, tt(main)'s code is surrounded by a tt(try)-block, forming an outer
level handling exceptions.  Within tt(main)'s tt(try)-block functions are
called which may also contain tt(try)-blocks, forming the next exception
level. As we have seen (section ref(EMPTYTHROW)), exceptions thrown in
inner level tt(try)-blocks may or may not be processed at that level. By
placing an empty tt(throw) statement in an exception handler, the
thrown exception is passed on to the next (outer) level.
