Fixed.

  "a link", http://an.aboslute.url

  and

  "a link":an absolute or relative URL

Fixes checked in earlier in the day to allow for only absolute URLs in the former broke regexes to do relative URLs in the latter.  This is now fixed.

FWIW, why we allow the first spelling is beyond me.  It has a tendency to be misinterpreted if it's not used with an absolute URL, which is why it's limited to matching absolute URLs currently.

 - All regexes attempt to now detect \r as well as \n as a newline character.

 - Fixed improper regex for emphasis which caused emphasized text to be rendered as strong.

 - Fixed href method to not return false positives for "comma", link:types.  In many cases, inappropriate things were being detected as comma-link-type hrefs.  Now only things with (http|https|ftp|mailto|file|about) as a leader are used as comma-link-types.

 - Changed ordered list types to not treat small words with following punctuation at the beginning of a paragraph (e.g. "Yes.") as an ordered list gesture.  Instead, only single characters (or any-length digits) followed by punctuation will be treated as an ordered list gesture.

- Removed unused regular expression from doc_header signature.

- Changed doc_literal, doc_emphasis, and doc_strong methods to
  work across newlines.  This means that people can start to type
  for example, a literal 'on one line and it should be ok to
  ... cross to the next'.  The danger here is that it will match
  too much (especially in the case of literals), but this is
  ameliorated by the fact that (at least for literals) the
  ending "'" is required to be followed by some kind of whitespace.
  Emphasis and strong don't have this limitation, but their symbology
  (*) is much less frequently used in normal writing.

do_startTag():  Only add in the length of the tag name once to determine
    alignment column for attributes.

 ways in which this was done was to use string.punctuation with locale support t
urned on, stuffing the results into regular expressions.

Unfortunately, the insertion of the punctuation into regular expressions was com
pletely literal.  This meant that, depending on locale, a regex could take on a
completely different semantic due to the fact that it could include "]", "?", et
c.  At times, this could cause a segmentation fault if a nonsensical generated r
egex was especially juicy.

I took out the code which localized punctuation, although the code which localiz
es letters is still there.

DocumentClass was changed to support alternate locates a while back.  One of the ways in which this was done was to use string.punctuation with locale support turned on, stuffing the results into regular expressions.

Unfortunately, the insertion of the punctuation into regular expressions was completely literal.  This meant that, depending on locale, a regex could take on a completely different semantic due to the fact that it could include "]", "?", etc.  At times, this could cause a segmentation fault if a nonsensical generated regex was especially juicy.

I took out the code which localized punctuation, although the code which localizes letters is still there.

example actually included some sample text.

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.