techniques of reducing the number of lookups and avoiding method
calls.

More interestingly, the dispatch machinery has changed, especially
TALInterpreter.iterpret().  Each instruction is now composed of a
2-tuple of the form (opcode, (arg1, arg2, ...)).  This is important as
it allows more efficient unpacking and construction of the argument
list for the call to the handlers for individual bytecodes.

The bytecode handlers are also located differently.  Instead of using
the opcode string to construct a method name, retrieve a bound method,
and then calling it via apply(), a dictionary of handler functions is
created as part of the class definition.  Handlers are retrieved from
this dictionary by opcode string (avoiding string concatenation and
bound method creation in the inner dispatch loop).  The handlers (now
functions rather than methods) are then called using apply(), creating
the arguments to the handler by tuple concatenation, which is faster
than creating the bound method and then using the slower
method-calling machinery.  Temporary variables are avoided whenever
possible.

The test for "debug mode" in TALInterpreter.interpret() was moved out
of the dispatch loop; it is used to select one of the two versions of
the loop.

Support has been added for two new bytecodes:
  rawtextColumn -- used when the TALGenerator can determine the
                   resulting column number ahead of time (the text
                   includes a newline)

  rawtextOffset -- used when the TALGenerator cannot determine the
                   final column of the text (there is no newline).

These new bytecodes allow the interpreter to avoid having to search
for a newline for all rawtext instructions -- the compiler is able to
determine which of these two cases is appropriate for each rawtext
chunk -- the old 'rawtext' instruction is no longer generated.

Re-phrased some conditions in if statements to allow more
short-circuiting.

    Very aggressively cache anything that involves a global lookup.

restrictedTraverse():
    Only cache things once it's possible we might use them.  Use the
    cached getattr() in one plase where the global was being looked up
    again.  Cache hasattr() as well.  Only construct the marker (M)
    once, not once for each call.

    The _push() and _pop() methods aren't really any different from
    the push() and pop() methods from the base MultiMap, so we can use
    them directly to avoid a lot of looks and method invocation
    overhead, and it's easier to tell from the code that they are just
    a renaming.

Context.beginScope(), .endScope():
    Move an attribute access out of the loop since the attribute isn't
    re-bound inside the loop.

Context.evaluateText():
    Re-phrase the condition in the if statement to allow the runtime
    to perform fewer global name lookups when possible, and avoid the
    tuple construction completely.

non XML compliant documents to be sent to a webdav client

Do not test for sys.exc_info(); it was already present in Python 2.1.
This simplifies code and improves performance (very slightly).

In two places, object type was tested by calling type() on each of two
values and comparing the results (4 dict lookups, 2 Python->C function
calls).  Replace each with an isinstance() call comparing to a saved
type object (3 dict lookups, 1 Python->C function call, more future-proof).

Moved ISO8601 into DateTime class.
DateTime constructor now also accepts ISO8601 dates.

Fixed (hopefully) a longtime outstanding problem in parens():
- the former regex never matched any parentheses
- the parens() used old regex module API although 're' module was used

- the former regex never matched any parentheses
- the parens() used old regex module API although 're' module was used

:img:

REQUEST object recently got a method named "text" that interfered with
the form elements name).

Only pick up mloads & mdumps from one location; since the "real" source is
marshal, we'll keep that one.

Added 'users_with_local_role' method.  This method takes a role string (e.g. 'Owner') as an argument and returns the usernames which have that local role respective to the object which is asked.  The username is returned as a bare string (without a database path).

Fix imports so that XML import works with Python 2.1.  The addition of
__all__ to the pickle module, and the import constraints that causes symbols
not listed in __all__ not to be imported by "import *", caused these modules
to break because some names were not acquired from the pickle module which
had been acquired before.

This patch adds the appropriate imports so that dependence on the pickle
module's implementation details is avoided.

PluginIndexes as first product in any case. (Collector #2273)

- made parseIndexRequest much more smarter in parsing the request parameter