print statements, but now passes.

multiple clauses.

Trimmed documentation of standard Python modules string, random, and math. It's too much work to try and track these. Better to just point users to official Python docs rather than transcribing them.

* Replaced references to the deprecated Guides with references to the Zope Book.
* Added links to the DTML reference section of the online help.
* Replaced ZopeTime examples with DateTime.
* Added a new lesson which show how to insert data into a database.

imports ImageFile, which imports from OFS.  This means that the import of
Globals is not complete during much of the Zope initialization procedure.
(This created problems with TransparentFolders.)

pDocumentTemplate compatibility is not vital, this solution
works well enough.

change is intended to solve it once and for all: there's now a "safe_callable"
function, implemented both in cDocumentTemplate and pDocumentTemplate, that
can more reliably check for callability.

A surprising side effect is that DTML is about 15% faster with this change
(according to a rudimentary test).

slower than the old code.  With this change, we're using simple function
calls again to perform security checks.  But the calling sequence is
intended to be easier to comprehend than the old code.  Now instead of
DT_String.String subclasses having a validate() method attached to them, they
subclass AccessControl.DTML.RestrictedDTML, which provides a guarded_getattr()
method and a guarded_getitem() method.

Note that the functionality of guarded_getattr() used to be implemented
both in C and Python (in cDocumentTemplate and DT_Util), but now it's in
one place, ZopeGuards.py.  Thus it's not only reusable but easy to
optimize.

I ran all the tests and ran the new code through the profiler again.  The
change sped up restricted code a little more than expected, which is
definitely a good thing, but that may indicate that nested scopes
have a hidden speed penalty.

Also, RestrictedPython is now restrictive about printing to targets and
two forms of augmented assignment had to be forbidden.

the cloned object was reattached to the object tree, which caused reindexing
of copied objects to fail.

  This is much faster (according to profiler results) than letting
  validate() check for simple types.

- Corrected handling of slice objects passed to guarded_getitem().

- Used guarded_getitem() instead of a read guard in guarded_map().

DT_String.String that adds Zope security.

instead of any other error that may be raised.

to my private branch

The doc_header method makes a copy of the paragraph it's working on and returns it in the case that what follows it is an example.  When doing so, the attributes attached to the paragraph were lost.  Changes made to the doc_header method copy the attributes assigned to the paragraph as well as the body, making the copy carry along paragraph attributes.

The indention function returned a bogus number of spaces in front of the string it was passed, causing subparagraphs of a paragraph that were indented by less than two spaces to appear at the same indent level as their parent paragraph.  This is now fixed, and paragraphs may be indented by a single space, just as they are in StructuredTextClassic.

Now, when products are installed, they are installed in alphabetical order by product name, regardless of which Products directory (e.g. INSTANCE_HOME or SOFTWARE_HOME) that they're in EXCEPT FOR PluginIndexes, which are always first, due to the requirement that they register interfaces with the product context machinery before ZCatalog is initialized.