The main is to provide a compliant, flexible and fast implementation of
the Python Language which uses
the RPython tool chain to enable new advanced high-level features without
having to encode the low-level details. This is called as PyPy.
High Level Goals
Our main motivation to develop
the translation framework that provides a full featured, customizable, fast and very
compliant Python implementation, working on and interacting
with a large variety of platforms and allowing the quick introduction of new
advanced language features.
This Python implementation is
written in RPython as a relatively simple
interpreter, in some respects, it is easier to understand than CPython, that is
C reference implementation of Python. Using its high level flexibility to
quickly experiment the features or implementation techniques in a traditional
approach, require pervasive changes to the source code.
For example, PyPy’s Python interpreter provides a lazily
computed object which is a small extension that would require global changes in
CPython.
Another example is the garbage
collection technique: changing CPython to use a garbage collector not based on
reference counting, whereas in PyPy it’s an issue localized in the translation
framework which is fully orthogonal to the interpreter source code.
PyPy Python Interpreter
PyPy’s Python Interpreter is
written in RPython that implements the full Python language. This interpreter
very closely emulates the behavior of CPython
and contains the following key components:
Bytecode
Compiler - This is responsible for
producing the Python code objects from the source code of a user application. The bytecode
compiler is the preprocessing phase which produces a compact bytecode
format via a chain of flexible passes (tokenizer, lexer, parser, abstract
syntax tree builder, bytecode generator).
Bytecode Evaluator –
It’s responsible for interpreting the Python code objects. The bytecode
evaluator interprets this bytecode. It does most of its work by
delegating all actual manipulations of user objects to the object space.
The latter can be thought of as the library of built-in types. It defines the
implementation of the user objects, like integers and lists, as well as the
operations between them, like addition or truth-value-testing.
Standard Object Space – This is responsible for creating and manipulating the Python objects that are seen by the
application. The division between bytecode evaluator and object space gives a
lot of flexibility. One can plug in different object spaces to
get different or enriched behaviour of the Python object.
If You Have any Queries?. Mention
it in the Comment Section, We will Clarify You Soon..!
