SF.net SVN: jython:[7238] trunk/jython
[email protected] Mon, 14 Mar 2011 16:54:15 +0000
| Newsgroups | gmane.comp.lang.jython.cvs |
|---|---|
| Message-ID | <[email protected]> |
Revision: 7238
http://jython.svn.sourceforge.net/jython/?rev=7238&view=rev
Author: pjenvey
Date: 2011-03-14 16:54:14 +0000 (Mon, 14 Mar 2011)
Log Message:
-----------
more includes for 2.6. I think this is all of them except abc/_abcoll/io/ssl
Modified Paths:
--------------
trunk/jython/CPythonLib.includes
Removed Paths:
-------------
trunk/jython/Lib/ast.py
Modified: trunk/jython/CPythonLib.includes
===================================================================
--- trunk/jython/CPythonLib.includes 2011-03-14 16:30:18 UTC (rev 7237)
+++ trunk/jython/CPythonLib.includes 2011-03-14 16:54:14 UTC (rev 7238)
@@ -18,6 +18,7 @@
_threading_local.py
aifc.py
anydbm.py
+ast.py
atexit.py
asynchat.py
BaseHTTPServer.py
@@ -59,8 +60,10 @@
fnmatch.py
formatter.py
fpformat.py
+fractions.py
ftplib.py
functools.py
+genericpath.py
getopt.py
glob.py
gopherlib.py
@@ -91,6 +94,7 @@
multifile.py
mutex.py
nntplib.py
+numbers.py
nturl2path.py
opcode.py
optparse.py
@@ -98,12 +102,14 @@
pickle.py
pickletools.py
pipes.py
+plistlib.py
poplib.py
posixfile.py
pprint.py
profile.py
pstats.py
pyclbr.py
+pydoc_topics.py
Queue.py
quopri.py
random.py
Deleted: trunk/jython/Lib/ast.py
===================================================================
--- trunk/jython/Lib/ast.py 2011-03-14 16:30:18 UTC (rev 7237)
+++ trunk/jython/Lib/ast.py 2011-03-14 16:54:14 UTC (rev 7238)
@@ -1,301 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
- ast
- ~~~
-
- The `ast` module helps Python applications to process trees of the Python
- abstract syntax grammar. The abstract syntax itself might change with
- each Python release; this module helps to find out programmatically what
- the current grammar looks like and allows modifications of it.
-
- An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as
- a flag to the `compile()` builtin function or by using the `parse()`
- function from this module. The result will be a tree of objects whose
- classes all inherit from `ast.AST`.
-
- A modified abstract syntax tree can be compiled into a Python code object
- using the built-in `compile()` function.
-
- Additionally various helper functions are provided that make working with
- the trees simpler. The main intention of the helper functions and this
- module in general is to provide an easy to use interface for libraries
- that work tightly with the python syntax (template engines for example).
-
-
- :copyright: Copyright 2008 by Armin Ronacher.
- :license: Python License.
-"""
-from _ast import *
-from _ast import __version__
-
-
-def parse(expr, filename='<unknown>', mode='exec'):
- """
- Parse an expression into an AST node.
- Equivalent to compile(expr, filename, mode, PyCF_ONLY_AST).
- """
- return compile(expr, filename, mode, PyCF_ONLY_AST)
-
-
-def literal_eval(node_or_string):
- """
- Safely evaluate an expression node or a string containing a Python
- expression. The string or node provided may only consist of the following
- Python literal structures: strings, numbers, tuples, lists, dicts, booleans,
- and None.
- """
- _safe_names = {'None': None, 'True': True, 'False': False}
- if isinstance(node_or_string, basestring):
- node_or_string = parse(node_or_string, mode='eval')
- if isinstance(node_or_string, Expression):
- node_or_string = node_or_string.body
- def _convert(node):
- if isinstance(node, Str):
- return node.s
- elif isinstance(node, Num):
- return node.n
- elif isinstance(node, Tuple):
- return tuple(map(_convert, node.elts))
- elif isinstance(node, List):
- return list(map(_convert, node.elts))
- elif isinstance(node, Dict):
- return dict((_convert(k), _convert(v)) for k, v
- in zip(node.keys, node.values))
- elif isinstance(node, Name):
- if node.id in _safe_names:
- return _safe_names[node.id]
- raise ValueError('malformed string')
- return _convert(node_or_string)
-
-
-def dump(node, annotate_fields=True, include_attributes=False):
- """
- Return a formatted dump of the tree in *node*. This is mainly useful for
- debugging purposes. The returned string will show the names and the values
- for fields. This makes the code impossible to evaluate, so if evaluation is
- wanted *annotate_fields* must be set to False. Attributes such as line
- numbers and column offsets are not dumped by default. If this is wanted,
- *include_attributes* can be set to True.
- """
- def _format(node):
- if isinstance(node, AST):
- fields = [(a, _format(b)) for a, b in iter_fields(node)]
- rv = '%s(%s' % (node.__class__.__name__, ', '.join(
- ('%s=%s' % field for field in fields)
- if annotate_fields else
- (b for a, b in fields)
- ))
- if include_attributes and node._attributes:
- rv += fields and ', ' or ' '
- rv += ', '.join('%s=%s' % (a, _format(getattr(node, a)))
- for a in node._attributes)
- return rv + ')'
- elif isinstance(node, list):
- return '[%s]' % ', '.join(_format(x) for x in node)
- return repr(node)
- if not isinstance(node, AST):
- raise TypeError('expected AST, got %r' % node.__class__.__name__)
- return _format(node)
-
-
-def copy_location(new_node, old_node):
- """
- Copy source location (`lineno` and `col_offset` attributes) from
- *old_node* to *new_node* if possible, and return *new_node*.
- """
- for attr in 'lineno', 'col_offset':
- if attr in old_node._attributes and attr in new_node._attributes \
- and hasattr(old_node, attr):
- setattr(new_node, attr, getattr(old_node, attr))
- return new_node
-
-
-def fix_missing_locations(node):
- """
- When you compile a node tree with compile(), the compiler expects lineno and
- col_offset attributes for every node that supports them. This is rather
- tedious to fill in for generated nodes, so this helper adds these attributes
- recursively where not already set, by setting them to the values of the
- parent node. It works recursively starting at *node*.
- """
- def _fix(node, lineno, col_offset):
- if 'lineno' in node._attributes:
- if not hasattr(node, 'lineno'):
- node.lineno = lineno
- else:
- lineno = node.lineno
- if 'col_offset' in node._attributes:
- if not hasattr(node, 'col_offset'):
- node.col_offset = col_offset
- else:
- col_offset = node.col_offset
- for child in iter_child_nodes(node):
- _fix(child, lineno, col_offset)
- _fix(node, 1, 0)
- return node
-
-
-def increment_lineno(node, n=1):
- """
- Increment the line number of each node in the tree starting at *node* by *n*.
- This is useful to "move code" to a different location in a file.
- """
- if 'lineno' in node._attributes:
- node.lineno = getattr(node, 'lineno', 0) + n
- for child in walk(node):
- if 'lineno' in child._attributes:
- child.lineno = getattr(child, 'lineno', 0) + n
- return node
-
-
-def iter_fields(node):
- """
- Yield a tuple of ``(fieldname, value)`` for each field in ``node._fields``
- that is present on *node*.
- """
- for field in node._fields:
- try:
- yield field, getattr(node, field)
- except AttributeError:
- pass
-
-
-def iter_child_nodes(node):
- """
- Yield all direct child nodes of *node*, that is, all fields that are nodes
- and all items of fields that are lists of nodes.
- """
- for name, field in iter_fields(node):
- if isinstance(field, AST):
- yield field
- elif isinstance(field, list):
- for item in field:
- if isinstance(item, AST):
- yield item
-
-
-def get_docstring(node, clean=True):
- """
- Return the docstring for the given node or None if no docstring can
- be found. If the node provided does not have docstrings a TypeError
- will be raised.
- """
- if not isinstance(node, (FunctionDef, ClassDef, Module)):
- raise TypeError("%r can't have docstrings" % node.__class__.__name__)
- if node.body and isinstance(node.body[0], Expr) and \
- isinstance(node.body[0].value, Str):
- if clean:
- import inspect
- return inspect.cleandoc(node.body[0].value.s)
- return node.body[0].value.s
-
-
-def walk(node):
- """
- Recursively yield all child nodes of *node*, in no specified order. This is
- useful if you only want to modify nodes in place and don't care about the
- context.
- """
- from collections import deque
- todo = deque([node])
- while todo:
- node = todo.popleft()
- todo.extend(iter_child_nodes(node))
- yield node
-
-
-class NodeVisitor(object):
- """
- A node visitor base class that walks the abstract syntax tree and calls a
- visitor function for every node found. This function may return a value
- which is forwarded by the `visit` method.
-
- This class is meant to be subclassed, with the subclass adding visitor
- methods.
-
- Per default the visitor functions for the nodes are ``'visit_'`` +
- class name of the node. So a `TryFinally` node visit function would
- be `visit_TryFinally`. This behavior can be changed by overriding
- the `visit` method. If no visitor function exists for a node
- (return value `None`) the `generic_visit` visitor is used instead.
-
- Don't use the `NodeVisitor` if you want to apply changes to nodes during
- traversing. For this a special visitor exists (`NodeTransformer`) that
- allows modifications.
- """
-
- def visit(self, node):
- """Visit a node."""
- method = 'visit_' + node.__class__.__name__
- visitor = getattr(self, method, self.generic_visit)
- return visitor(node)
-
- def generic_visit(self, node):
- """Called if no explicit visitor function exists for a node."""
- for field, value in iter_fields(node):
- if isinstance(value, list):
- for item in value:
- if isinstance(item, AST):
- self.visit(item)
- elif isinstance(value, AST):
- self.visit(value)
-
-
-class NodeTransformer(NodeVisitor):
- """
- A :class:`NodeVisitor` subclass that walks the abstract syntax tree and
- allows modification of nodes.
-
- The `NodeTransformer` will walk the AST and use the return value of the
- visitor methods to replace or remove the old node. If the return value of
- the visitor method is ``None``, the node will be removed from its location,
- otherwise it is replaced with the return value. The return value may be the
- original node in which case no replacement takes place.
-
- Here is an example transformer that rewrites all occurrences of name lookups
- (``foo``) to ``data['foo']``::
-
- class RewriteName(NodeTransformer):
-
- def visit_Name(self, node):
- return copy_location(Subscript(
- value=Name(id='data', ctx=Load()),
- slice=Index(value=Str(s=node.id)),
- ctx=node.ctx
- ), node)
-
- Keep in mind that if the node you're operating on has child nodes you must
- either transform the child nodes yourself or call the :meth:`generic_visit`
- method for the node first.
-
- For nodes that were part of a collection of statements (that applies to all
- statement nodes), the visitor may also return a list of nodes rather than
- just a single node.
-
- Usually you use the transformer like this::
-
- node = YourTransformer().visit(node)
- """
-
- def generic_visit(self, node):
- for field, old_value in iter_fields(node):
- old_value = getattr(node, field, None)
- if isinstance(old_value, list):
- new_values = []
- for value in old_value:
- if isinstance(value, AST):
- value = self.visit(value)
- if value is None:
- continue
- elif not isinstance(value, AST):
- new_values.extend(value)
- continue
- new_values.append(value)
- old_value[:] = new_values
- elif isinstance(old_value, AST):
- new_node = self.visit(old_value)
- if new_node is None:
- delattr(node, field)
- else:
- setattr(node, field, new_node)
- return node
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
------------------------------------------------------------------------------
Colocation vs. Managed Hosting
A question and answer guide to determining the best fit
for your organization - today and in the future.
http://p.sf.net/sfu/internap-sfd2d