What’s in the Source Code?

The CPython source distribution comes with a whole range of tools, libraries, and components. We’ll explore those in this article. First we are going to focus on the compiler.

To download a copy of the CPython source code, you can usegit to pull the latest version to a working copy locally:

$gitclonehttps://github.com/python/cpython$cdcpython$gitcheckoutv3.8.0b4

Inside of the newly downloadedcpython directory, you will find the following subdirectories:

cpython/│├── Doc      ← Source for the documentation├── Grammar  ← The computer-readable language definition├── Include  ← The C header files├── Lib      ← Standard library modules written in Python├── Mac      ← macOS support files├── Misc     ← Miscellaneous files├── Modules  ← Standard Library Modules written in C├── Objects  ← Core types and the object model├── Parser   ← The Python parser source code├── PC       ← Windows build support files├── PCbuild  ← Windows build support files for older Windows versions├── Programs ← Source code for the python executable and other binaries├── Python   ← The CPython interpreter source code└── Tools    ← Standalone tools useful for building or extending Python

Next, we’ll compile CPython from the source code. This step requires a C compiler, and some build tools, which depend on the operating system you’re using.

Compiling CPython (macOS)

Compiling CPython on macOS is straightforward. You will first need the essential C compiler toolkit. The Command Line Development Tools is an app that you can update in macOS through the App Store. You need to perform the initial installation on the terminal.

To open up a terminal in macOS, go to the Launchpad, thenOther then choose theTerminal app. You will want to save this app to your Dock, so right-click the Icon and selectKeep in Dock.

Now, within the terminal, install the C compiler and toolkit by running the following:

$xcode-select--install

This command will pop up with a prompt to download and install a set of tools, including Git, Make, and the GNU C compiler.

You will also need a working copy ofOpenSSL to use for fetching packages from the PyPi.org website. If you later plan on using this build to install additional packages, SSL validation is required.

The simplest way to install OpenSSL on macOS is by usingHomeBrew. If you already have HomeBrew installed, you can install the dependencies for CPython with thebrew install command:

$brewinstallopensslxzzlib

Now that you have the dependencies, you can run theconfigure script, enabling SSL support by discovering the location that HomeBrew installed to and enabling the debug hooks--with-pydebug:

$CPPFLAGS="-I$(brew--prefixzlib)/include"\LDFLAGS="-L$(brew--prefixzlib)/lib"\./configure--with-openssl=$(brew--prefixopenssl)--with-pydebug

This will generate aMakefile in the root of the repository that you can use to automate the build process. The./configure step only needs to be run once. You can build the CPython binary by running:

$make-j2-s

The-j2 flag allowsmake to run 2 jobs simultaneously. If you have 4 cores, you can change this to 4. The-s flag stops theMakefile from printing every command it runs to the console. You can remove this, but the output is very verbose.

During the build, you may receive some errors, and in the summary, it will notify you that not all packages could be built. For example,_dbm,_sqlite3,_uuid,nis,ossaudiodev,spwd, and_tkinter would fail to build with this set of instructions. That’s okay if you aren’t planning on developing against those packages. If you are, then check out thedev guide website for more information.

The build will take a few minutes and generate a binary calledpython.exe. Every time you make changes to the source code, you will need to re-runmake with the same flags.Thepython.exe binary is the debug binary of CPython. Executepython.exe to see a working REPL:

$./python.exePython 3.8.0b4 (tags/v3.8.0b4:d93605de72, Aug 30 2019, 10:00:03)[Clang 10.0.1 (clang-1001.0.46.4)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>

Compiling CPython (Linux)

For Linux, the first step is to download and installmake,gcc,configure, andpkgconfig.

For Fedora Core, RHEL, CentOS, or other yum-based systems:

$sudoyuminstallyum-utils

For Debian, Ubuntu, or otherapt-based systems:

$sudoaptinstallbuild-essential

Then install the required packages, for Fedora Core, RHEL, CentOS or other yum-based systems:

$sudoyum-builddeppython3

For Debian, Ubuntu, or otherapt-based systems:

$sudoaptinstalllibssl-devzlib1g-devlibncurses5-dev\libncursesw5-devlibreadline-devlibsqlite3-devlibgdbm-dev\libdb5.3-devlibbz2-devlibexpat1-devliblzma-devlibffi-dev

Now that you have the dependencies, you can run theconfigure script, enabling the debug hooks--with-pydebug:

$./configure--with-pydebug

Review the output to ensure that OpenSSL support was marked asYES. Otherwise, check with your distribution for instructions on installing the headers for OpenSSL.

Next, you can build the CPython binary by running the generatedMakefile:

$make-j2-s

During the build, you may receive some errors, and in the summary, it will notify you that not all packages could be built. That’s okay if you aren’t planning on developing against those packages. If you are, then check out thedev guide website for more information.

The build will take a few minutes and generate a binary calledpython. This is the debug binary of CPython. Execute./python to see a working REPL:

$./pythonPython 3.8.0b4 (tags/v3.8.0b4:d93605de72, Aug 30 2019, 10:00:03)[Clang 10.0.1 (clang-1001.0.46.4)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>

Compiling CPython (Windows)

Inside the PC folder is a Visual Studio project file for building and exploring CPython. To use this, you need to have Visual Studio installed on your PC.

The newest version of Visual Studio, Visual Studio 2019, makes it easier to work with Python and the CPython source code, so it is recommended for use in this tutorial. If you already have Visual Studio 2017 installed, that would also work fine.

None of the paid features are required for compiling CPython or this tutorial. You can use the Community edition of Visual Studio, which is available for free fromMicrosoft’s Visual Studio website.

Once you’ve downloaded the installer, you’ll be asked to select which components you want to install. The bare minimum for this tutorial is:

• ThePython Development workload
• The optionalPython native development tools
• Python 3 64-bit (3.7.2) (can be deselected if you already have Python 3.7 installed)

Any other optional features can be deselected if you want to be more conscientious with disk space:

The installer will then download and install all of the required components. The installation could take an hour, so you may want to read on and come back to this section.

Once the installer has completed, click theLaunch button to start Visual Studio. You will be prompted to sign in. If you have a Microsoft account you can log in, or skip that step.

Once Visual Studio starts, you will be prompted to Open a Project. A shortcut to getting started with the Git configuration and cloning CPython is to choose theClone or check out code option:

For the project URL, typehttps://github.com/python/cpython to clone:

Visual Studio will then download a copy of CPython from GitHub using the version of Git bundled with Visual Studio. This step also saves you the hassle of having to install Git on Windows. The download may take 10 minutes.

Once the project has downloaded, you need to point it to thepcbuild Solution file, by clicking onSolutions and Projects and selectingpcbuild.sln:

When the solution is loaded, it will prompt you to retarget the project’s inside the solution to the version of the C/C++ compiler you have installed. Visual Studio will also target the version of the Windows SDK you have installed.

Ensure that you change the Windows SDK version to the newest installed version and the platform toolset to the latest version. If you missed this window, you can right-click on the Solution in theSolutions and Projects window and clickRetarget Solution.

Once this is complete, you need to download some source files to be able to build the whole CPython package. Inside thePCBuild folder there is a.bat file that automates this for you.Open up a command-line prompt inside the downloadedPCBuild and runget_externals.bat:

 > get_externals.batUsing py -3.7 (found 3.7 with py.exe)Fetching external libraries...Fetching bzip2-1.0.6...Fetching sqlite-3.21.0.0...Fetching xz-5.2.2...Fetching zlib-1.2.11...Fetching external binaries...Fetching openssl-bin-1.1.0j...Fetching tcltk-8.6.9.0...Finished.

Next, back within Visual Studio, build CPython by pressingCtrl+Shift+B, or choosingBuild Solution from the top menu. If you receive any errors about the Windows SDK being missing, make sure you set the right targeting settings in theRetarget Solution window. You should also seeWindows Kits inside your Start Menu, andWindows Software Development Kit inside of that menu.

The build stage could take 10 minutes or more for the first time. Once the build is completed, you may see a few warnings that you can ignore and eventual completion.

To start the debug version of CPython, pressF5 and CPython will start in Debug mode straight into the REPL:

Once this is completed, you can run the Release build by changing the build configuration fromDebug toRelease on the top menu bar and rerunning Build Solution again.You now have both Debug and Release versions of the CPython binary withinPCBuild\win32\.

You can set up Visual Studio to be able to open a REPL with either the Release or Debug build by choosingTools->Python->Python Environments from the top menu:

Then clickAdd Environment and then target the Debug or Release binary. The Debug binary will end in_d.exe, for example,python_d.exe andpythonw_d.exe. You will most likely want to use the debug binary as it comes with Debugging support in Visual Studio and will be useful for this tutorial.

In the Add Environment window, target thepython_d.exe file as the interpreter inside thePCBuild/win32 and thepythonw_d.exe as the windowed interpreter:

Now, you can start a REPL session by clickingOpen Interactive Window in the Python Environments window and you will see the REPL for the compiled version of Python:

During this tutorial there will be REPL sessions with example commands. I encourage you to use the Debug binary to run these REPL sessions in case you want to put in any breakpoints within the code.

Lastly, to make it easier to navigate the code, in the Solution View, click on the toggle button next to the Home icon to switch to Folder view:

Now you have a version of CPython compiled and ready to go, let’s find out how the CPython compiler works.

What Does a Compiler Do?

The purpose of a compiler is to convert one language into another. Think of a compiler like a translator. You would hire a translator to listen to you speaking in English and then speak in Japanese:

Some compilers will compile into a low-level machine code which can be executed directly on a system. Other compilers will compile into an intermediary language, to be executed by a virtual machine.

One important decision to make when choosing a compiler is the system portability requirements.Java and.NET CLR will compile into an Intermediary Language so that the compiled code is portable across multiple systems architectures. C, Go, C++, and Pascal will compile into a low-level executable that will only work on systems similar to the one it was compiled.

Because Python applications are typically distributed as source code, the role of the Python runtime is to convert the Python source code and execute it in one step. Internally, the CPython runtime does compile your code. A popular misconception is that Python is an interpreted language. It is actually compiled.

Python code is not compiled into machine-code. It is compiled into a special low-level intermediary language calledbytecode that only CPython understands. This code is stored in.pyc files in a hidden directory and cached for execution. If you run the same Python application twice without changing the source code, it’ll always be much faster the second time. This is because it loads the compiled bytecode and executes it directly.

Why Is CPython Written in C and Not Python?

TheC in CPython is a reference to the C programming language, implying that this Python distribution is written in the C language.

This statement is largely true: the compiler in CPython is written in pure C. However, many of the standard library modules are written in pure Python or a combination of C and Python.

So why is CPython written in C and not Python?

The answer is located in how compilers work. There are two types of compiler:

1. Self-hosted compilers are compilers written in the language they compile, such as the Go compiler.
2. Source-to-source compilers are compilers written in another language that already have a compiler.

If you’re writing a new programming language from scratch, you need an executable application to compile your compiler! You need a compiler to execute anything, so when new languages are developed, they’re often written first in an older, more established language.

A good example would be the Go programming language. The first Go compiler was written in C, then once Go could be compiled, the compiler was rewritten in Go.

CPython kept its C heritage: many of the standard library modules, like thessl module or thesockets module, are written in C to access low-level operating system APIs.The APIs in the Windows and Linux kernels forcreating network sockets,working with the filesystem orinteracting with the display are all written in C. It made sense for Python’s extensibility layer to be focused on the C language. Later in this article, we will cover the Python Standard Library and the C modules.

There is a Python compiler written in Python calledPyPy. PyPy’s logo is anOuroboros to represent the self-hosting nature of the compiler.

Another example of a cross-compiler for Python isJython. Jython is written in Java and compiles from Python source code into Java bytecode. In the same way that CPython makes it easy to import C libraries and use them from Python, Jython makes it easy to import and reference Java modules and classes.

The Python Language Specification

Contained within the CPython source code is the definition of the Python language. This is the reference specification used by all the Python interpreters.

The specification is in both human-readable and machine-readable format. Inside the documentation is a detailed explanation of the Python language, what is allowed, and how each statement should behave.

cpython/Doc/reference|├── compound_stmts.rst├── datamodel.rst├── executionmodel.rst├── expressions.rst├── grammar.rst├── import.rst├── index.rst├── introduction.rst├── lexical_analysis.rst├── simple_stmts.rst└── toplevel_components.rst

withx():...

withx()asy:...

withx()asy,z()asjk:...

with_stmt: 'with' with_item (',' with_item)*  ':' suitewith_item: test ['as' expr]

pass_stmt: 'pass'

pass_stmt: 'pass' | 'proceed'

# Regenerate Doc/library/token-list.inc from Grammar/Tokens# using Tools/scripts/generate_token.py...python3 ./Tools/scripts/update_file.py ./Include/graminit.h ./Include/graminit.h.newpython3 ./Tools/scripts/update_file.py ./Python/graminit.c ./Python/graminit.c.new

Python 3.8.0b4 (tags/v3.8.0b4:d93605de72, Aug 30 2019, 10:00:03) [Clang 10.0.1 (clang-1001.0.46.4)] on darwinType "help", "copyright", "credits" or "license" for more information.>>> def example():...    proceed... >>> example()

Tokens

Alongside the grammar file in theGrammar folder is aTokens file, which contains each of the unique types found as a leaf node in a parse tree. We will cover parser trees in depth later.Each token also has a name and a generated unique ID. The names are used to make it simpler to refer to in the tokenizer.

Note: TheTokens file is a new feature in Python 3.8.

For example, the left parenthesis is calledLPAR, and semicolons are calledSEMI. You’ll see these tokens later in the article:

Text

LPAR                    '('RPAR                    ')'LSQB                    '['RSQB                    ']'COLON                   ':'COMMA                   ','SEMI                    ';'

As with theGrammar file, if you change theTokens file, you need to runpgen again.

To see tokens in action, you can use thetokenize module in CPython. Create a simple Python script calledtest_tokens.py:

Python

# Hello world!defmy_function():proceed

For the rest of this tutorial,./python.exe will refer to the compiled version of CPython. However, the actual command will depend on your system.

For Windows:

Shell

 > python.exe

For Linux:

Shell

 > ./python

For macOS:

Shell

 > ./python.exe

Then pass this file through a module built into the standard library calledtokenize. You will see the list of tokens, by line and character. Use the-e flag to output the exact token name:

Shell

$./python.exe-mtokenize-etest_tokens.py0,0-0,0:            ENCODING       'utf-8'1,0-1,14:           COMMENT        '# Hello world!'1,14-1,15:          NL             '\n'2,0-2,3:            NAME           'def'2,4-2,15:           NAME           'my_function'2,15-2,16:          LPAR           '('2,16-2,17:          RPAR           ')'2,17-2,18:          COLON          ':'2,18-2,19:          NEWLINE        '\n'3,0-3,3:            INDENT         '   '3,3-3,7:            NAME           'proceed'3,7-3,8:            NEWLINE        '\n'4,0-4,0:            DEDENT         ''4,0-4,0:            ENDMARKER      ''

In the output, the first column is the range of the line/column coordinates, the second column is the name of the token, and the final column is the value of the token.

In the output, thetokenize module has implied some tokens that were not in the file. TheENCODING token forutf-8, and a blank line at the end, givingDEDENT to close the function declaration and anENDMARKER to end the file.

It is best practice to have a blank line at the end of your Python source files. If you omit it, CPython adds it for you, with a tiny performance penalty.

Thetokenize module is written in pure Python and is located inLib/tokenize.py within the CPython source code.

Important: There are two tokenizers in the CPython source code: one written in Python, demonstrated here, and another written in C.The tokenizer written in Python is meant as a utility, and the one written in C is used by the Python compiler. They have identical output and behavior. The version written in C is designed for performance and the module in Python is designed for debugging.

To see a verbose readout of the C tokenizer, you can run Python with the-d flag. Using thetest_tokens.py script you created earlier, run it with the following:

Shell

$./python.exe-dtest_tokens.pyToken NAME/'def' ... It's a keyword DFA 'file_input', state 0: Push 'stmt' DFA 'stmt', state 0: Push 'compound_stmt' DFA 'compound_stmt', state 0: Push 'funcdef' DFA 'funcdef', state 0: Shift.Token NAME/'my_function' ... It's a token we know DFA 'funcdef', state 1: Shift.Token LPAR/'(' ... It's a token we know DFA 'funcdef', state 2: Push 'parameters' DFA 'parameters', state 0: Shift.Token RPAR/')' ... It's a token we know DFA 'parameters', state 1: Shift.  DFA 'parameters', state 2: Direct pop.Token COLON/':' ... It's a token we know DFA 'funcdef', state 3: Shift.Token NEWLINE/'' ... It's a token we know DFA 'funcdef', state 5: [switch func_body_suite to suite] Push 'suite' DFA 'suite', state 0: Shift.Token INDENT/'' ... It's a token we know DFA 'suite', state 1: Shift.Token NAME/'proceed' ... It's a keyword DFA 'suite', state 3: Push 'stmt'...  ACCEPT.

In the output, you can see that it highlightedproceed as a keyword. In the next chapter, we’ll see how executing the Python binary gets to the tokenizer and what happens from there to execute your code.

Now that you have an overview of the Python grammar and the relationship between tokens and statements, there is a way to convert thepgen output into an interactive graph.

Here is a screenshot of the Python 3.8a2 grammar:

The Python package used to generate this graph,instaviz, will be covered in a later chapter.

Remove ads

Memory Management in CPython

Throughout this article, you will see references to aPyArena object. The arena is one of CPython’s memory management structures. The code is withinPython/pyarena.c and contains a wrapper around C’s memory allocation and deallocation functions.

In a traditionally written C program, the developershould allocate memory for data structures before writing into that data. This allocation marks the memory as belonging to the process with the operating system.

It is also up to the developer to deallocate, or “free,” the allocated memory when its no longer being used and return it to the operating system’s block table of free memory. If a process allocates memory for a variable, say within a function or loop, when that function has completed, the memory is not automatically given back to the operating system in C. So if it hasn’t been explicitly deallocated in the C code, it causes a memory leak. The process will continue to take more memory each time that function runs until eventually, the system runs out of memory, and crashes!

Python takes that responsibility away from the programmer and uses two algorithms:a reference counter and a garbage collector.

Whenever an interpreter is instantiated, aPyArena is created and attached one of the fields in the interpreter. During the lifecycle of a CPython interpreter, many arenas could be allocated. They are connected with alinked list. The arena stores a list of pointers to Python Objects as aPyListObject. Whenever a new Python object is created, a pointer to it is added usingPyArena_AddPyObject(). This function call stores a pointer in the arena’s list,a_objects.

ThePyArena serves a second function, which is to allocate and reference a list of raw memory blocks. For example, aPyList would need extra memory if you added thousands of additional values. ThePyList object’s C code does not allocate memory directly. The object gets raw blocks of memory from thePyArena by callingPyArena_Malloc() from thePyObject with the required memory size. This task is completed by another abstraction inObjects/obmalloc.c. In the object allocation module, memory can be allocated, freed, and reallocated for a Python Object.

A linked list of allocated blocks is stored inside the arena, so that when an interpreter is stopped, all managed memory blocks can be deallocated in one go usingPyArena_Free().

Take thePyListObject example. If you were to.append() an object to the end of a Python list, you don’t need to reallocate the memory used in the existing list beforehand. The.append() method callslist_resize() which handles memory allocation for lists. Each list object keeps a list of the amount of memory allocated. If the item you’re appending will fit inside the existing free memory, it is simply added. If the list needs more memory space, it is expanded. Lists are expanded in length as 0, 4, 8, 16, 25, 35, 46, 58, 72, 88.

PyMem_Realloc() is called to expand the memory allocated in a list.PyMem_Realloc() is an API wrapper forpymalloc_realloc().

Python also has a special wrapper for the C callmalloc(), which sets the max size of the memory allocation to help prevent buffer overflow errors (SeePyMem_RawMalloc()).

In summary:

• Allocation of raw memory blocks is done viaPyMem_RawAlloc().
• The pointers to Python objects are stored within thePyArena.
• PyArena also stores a linked-list of allocated memory blocks.

More information on the API is detailed on theCPython documentation.

my_variable=180392

>>>importgc>>>gc.set_debug(gc.DEBUG_STATS)

>>>gc.get_threshold()(700, 10, 10)

>>>gc.get_count()(688, 1, 1)

>>>gc.collect()24

Conclusion

In Part 1, you covered the structure of the source code repository, how to compile from source, and the Python language specification. These core concepts will be critical in Part 2 as you dive deeper into the Python interpreter process.

Establishing Runtime Configuration

In the swimlanes, you can see that before any Python code is executed, the runtime first establishes the configuration.The configuration of the runtime is a data structure defined inInclude/cpython/initconfig.h namedPyConfig.

The configuration data structure includes things like:

• Runtime flags for various modes like debug and optimized mode
• The execution mode, such as whether a filename was passed,stdin was provided or a module name
• Extended option, specified by-X <option>
• Environment variables for runtime settings

The configuration data is primarily used by the CPython runtime to enable and disable various features.

Python also comes with severalCommand Line Interface Options. In Python you can enable verbose mode with the-v flag. In verbose mode, Python will print messages to the screen when modules are loaded:

$./python.exe-v-c"print('hello world')"#installingzipimporthookimport zipimport # builtin#installedzipimporthook...

You will see a hundred lines or more with all the imports of your user site-packages and anything else in the system environment.

You can see the definition of this flag withinInclude/cpython/initconfig.h inside thestruct forPyConfig:

/* --- PyConfig ---------------------------------------------- */typedefstruct{int_config_version;/* Internal configuration version,                             used for ABI compatibility */int_config_init;/* _PyConfigInitEnum value */.../* If greater than 0, enable the verbose mode: print a message each time a       module is initialized, showing the place (filename or built-in module)       from which it is loaded.       If greater or equal to 2, print a message for each file that is checked       for when searching for a module. Also provides information on module       cleanup at exit.       Incremented by the -v option. Set by the PYTHONVERBOSE environment       variable. If set to -1 (default), inherit Py_VerboseFlag value. */intverbose;

InPython/initconfig.c, the logic for reading settings from environment variables and runtime command-line flags is established.

In theconfig_read_env_vars function, the environment variables are read and used to assign the values for the configuration settings:

staticPyStatusconfig_read_env_vars(PyConfig*config){PyStatusstatus;intuse_env=config->use_environment;/* Get environment variables */_Py_get_env_flag(use_env,&config->parser_debug,"PYTHONDEBUG");_Py_get_env_flag(use_env,&config->verbose,"PYTHONVERBOSE");_Py_get_env_flag(use_env,&config->optimization_level,"PYTHONOPTIMIZE");_Py_get_env_flag(use_env,&config->inspect,"PYTHONINSPECT");

For the verbose setting, you can see that the value ofPYTHONVERBOSE is used to set the value of&config->verbose, ifPYTHONVERBOSE is found. If the environment variable does not exist, then the default value of-1 will remain.

Then inconfig_parse_cmdline withininitconfig.c again, the command-line flag is used to set the value, if provided:

staticPyStatusconfig_parse_cmdline(PyConfig*config,PyWideStringList*warnoptions,Py_ssize_t*opt_index){...switch(c){...case'v':config->verbose++;break;.../* This space reserved for other options */default:/* unknown argument: parsing failed */config_usage(1,program);return_PyStatus_EXIT(2);}}while(1);

This value is later copied to a global variablePy_VerboseFlag by the_Py_GetGlobalVariablesAsDict function.

Within a Python session, you can access the runtime flags, like verbose mode, quiet mode, using thesys.flags named tuple.The-X flags are all available inside thesys._xoptions dictionary:

$ ./python.exe -X dev -q>>>importsys>>>sys.flagssys.flags(debug=0, inspect=0, interactive=0, optimize=0, dont_write_bytecode=0, no_user_site=0, no_site=0, ignore_environment=0, verbose=0, bytes_warning=0, quiet=1, hash_randomization=1, isolated=0, dev_mode=True, utf8_mode=0)>>>sys._xoptions{'dev': True}

As well as the runtime configuration ininitconfig.h, there is also the build configuration, which is located insidepyconfig.h in the root folder. This file is created dynamically in theconfigure step in the build process, or by Visual Studio for Windows systems.

You can see the build configuration by running:

$./python.exe-msysconfig

Reading Files/Input

Once CPython has the runtime configuration and the command-line arguments, it can establish what it needs to execute.

This task is handled by thepymain_main function insideModules/main.c. Depending on the newly createdconfig instance, CPython will now execute code provided via several options.

Input via-c

The simplest is providing CPython a command with the-c option and a Python program inside quotes.

For example:

Shell

$./python.exe-c"print('hi')"hi

Here is the full flowchart of how this happens:

First, thepymain_run_command() function is executed insideModules/main.c taking the command passed in-c as an argument in the C typewchar_t*. Thewchar_t* type is often used as a low-level storage type forUnicode data across CPython as the size of the type can store UTF8 characters.

When converting thewchar_t* to a Python string, theObjects/unicodeobject.c file has a helper functionPyUnicode_FromWideChar() that returns aPyObject, of typestr. The encoding to UTF-8 is then done byPyUnicode_AsUTF8String() on the Pythonstr object to convert it to a Pythonbytes object.

Once this is complete,pymain_run_command() will then pass the Pythonbytes object toPyRun_SimpleStringFlags() for execution, but first converting thebytes to astr type again:

C

staticintpymain_run_command(wchar_t*command,PyCompilerFlags*cf){PyObject*unicode,*bytes;intret;unicode=PyUnicode_FromWideChar(command,-1);if(unicode==NULL){gotoerror;}if(PySys_Audit("cpython.run_command","O",unicode)<0){returnpymain_exit_err_print();}bytes=PyUnicode_AsUTF8String(unicode);Py_DECREF(unicode);if(bytes==NULL){gotoerror;}ret=PyRun_SimpleStringFlags(PyBytes_AsString(bytes),cf);Py_DECREF(bytes);return(ret!=0);error:PySys_WriteStderr("Unable to decode the command from the command line:\n");returnpymain_exit_err_print();}

The conversion ofwchar_t* to Unicode, bytes, and then a string is roughly equivalent to the following:

Python

unicode=str(command)bytes_=bytes(unicode.encode('utf8'))# call PyRun_SimpleStringFlags with bytes_

ThePyRun_SimpleStringFlags() function is part ofPython/pythonrun.c. It’s purpose is to turn this simple command into a Python module and then send it on to be executed.Since a Python module needs to have__main__ to be executed as a standalone module, it creates that automatically:

C

intPyRun_SimpleStringFlags(constchar*command,PyCompilerFlags*flags){PyObject*m,*d,*v;m=PyImport_AddModule("__main__");if(m==NULL)return-1;d=PyModule_GetDict(m);v=PyRun_StringFlags(command,Py_file_input,d,d,flags);if(v==NULL){PyErr_Print();return-1;}Py_DECREF(v);return0;}

OncePyRun_SimpleStringFlags() has created a module and a dictionary, it callsPyRun_StringFlags(), which creates a fake filename and then calls the Python parser to create an AST from the string and return a module,mod:

C

PyObject*PyRun_StringFlags(constchar*str,intstart,PyObject*globals,PyObject*locals,PyCompilerFlags*flags){...mod=PyParser_ASTFromStringObject(str,filename,start,flags,arena);if(mod!=NULL)ret=run_mod(mod,filename,globals,locals,flags,arena);PyArena_Free(arena);returnret;

You’ll dive into the AST and Parser code in the next section.

staticintpymain_run_module(constwchar_t*modname,intset_argv0){PyObject*module,*runpy,*runmodule,*runargs,*result;runpy=PyImport_ImportModule("runpy");...runmodule=PyObject_GetAttrString(runpy,"_run_module_as_main");...module=PyUnicode_FromWideChar(modname,wcslen(modname));...runargs=Py_BuildValue("(Oi)",module,set_argv0);...result=PyObject_Call(runmodule,runargs,NULL);...if(result==NULL){returnpymain_exit_err_print();}Py_DECREF(result);return0;}

hi="hi!"hi.upper()==hi.upper.__call__()# this is the same

intPyRun_SimpleFileExFlags(FILE*fp,constchar*filename,intcloseit,PyCompilerFlags*flags){...m=PyImport_AddModule("__main__");...if(maybe_pyc_file(fp,filename,ext,closeit)){...v=run_pyc_file(pyc_fp,filename,d,d,flags);}else{/* When running from stdin, leave __main__.__loader__ alone */if(strcmp(filename,"<stdin>")!=0&&set_main_loader(d,filename,"SourceFileLoader")<0){fprintf(stderr,"python: failed to set __main__.__loader__\n");ret=-1;gotodone;}v=PyRun_FileExFlags(fp,filename,Py_file_input,d,d,closeit,flags);}...returnret;}

PyObject*PyRun_FileExFlags(FILE*fp,constchar*filename_str,intstart,PyObject*globals,PyObject*locals,intcloseit,PyCompilerFlags*flags){...mod=PyParser_ASTFromFileObject(fp,filename,NULL,start,0,0,flags,NULL,arena);...ret=run_mod(mod,filename,globals,locals,flags,arena);}

staticPyObject*run_mod(mod_tymod,PyObject*filename,PyObject*globals,PyObject*locals,PyCompilerFlags*flags,PyArena*arena){PyCodeObject*co;PyObject*v;co=PyAST_CompileObject(mod,filename,flags,-1,arena);if(co==NULL)returnNULL;if(PySys_Audit("exec","O",co)<0){Py_DECREF(co);returnNULL;}v=run_eval_code_obj(co,globals,locals);Py_DECREF(co);returnv;}

staticPyObject*run_pyc_file(FILE*fp,constchar*filename,PyObject*globals,PyObject*locals,PyCompilerFlags*flags){PyCodeObject*co;PyObject*v;...v=PyMarshal_ReadLastObjectFromFile(fp);...if(v==NULL||!PyCode_Check(v)){Py_XDECREF(v);PyErr_SetString(PyExc_RuntimeError,"Bad code object in .pyc file");gotoerror;}fclose(fp);co=(PyCodeObject*)v;v=run_eval_code_obj(co,globals,locals);if(v&&flags)flags->cf_flags|=(co->co_flags&PyCF_MASK);Py_DECREF(co);returnv;}

Lexing and Parsing

In the exploration of reading and executing Python files, we dived as deep as the parser and AST modules, with function calls toPyParser_ASTFromFileObject().

Sticking withinPython/pythonrun.c, thePyParser_ASTFromFileObject() function will take a file handle, compiler flags and aPyArena instance and convert the file object into a node object usingPyParser_ParseFileObject().

With the node object, it will then convert that into a module using the AST functionPyAST_FromNodeObject():

mod_tyPyParser_ASTFromFileObject(FILE*fp,PyObject*filename,constchar*enc,intstart,constchar*ps1,constchar*ps2,PyCompilerFlags*flags,int*errcode,PyArena*arena){...node*n=PyParser_ParseFileObject(fp,filename,enc,&_PyParser_Grammar,start,ps1,ps2,&err,&iflags);...if(n){flags->cf_flags|=iflags&PyCF_MASK;mod=PyAST_FromNodeObject(n,flags,filename,arena);PyNode_Free(n);...returnmod;}

ForPyParser_ParseFileObject() we switch toParser/parsetok.c and the parser-tokenizer stage of the CPython interpreter. This function has two important tasks:

1. Instantiate a tokenizer statetok_state usingPyTokenizer_FromFile() inParser/tokenizer.c
2. Convert the tokens into a concrete parse tree (a list ofnode) usingparsetok() inParser/parsetok.c

node*PyParser_ParseFileObject(FILE*fp,PyObject*filename,constchar*enc,grammar*g,intstart,constchar*ps1,constchar*ps2,perrdetail*err_ret,int*flags){structtok_state*tok;...if((tok=PyTokenizer_FromFile(fp,enc,ps1,ps2))==NULL){err_ret->error=E_NOMEM;returnNULL;}...returnparsetok(tok,g,start,err_ret,flags);}

tok_state (defined inParser/tokenizer.h) is the data structure to store all temporary data generated by the tokenizer. It is returned to the parser-tokenizer as the data structure is required byparsetok() to develop the concrete syntax tree.

Insideparsetok(), it will use thetok_state structure and make calls totok_get() in a loop until the file is exhausted and no more tokens can be found.

tok_get(), defined inParser/tokenizer.c behaves like an iterator. It will keep returning the next token in the parse tree.

tok_get() is one of the most complex functions in the whole CPython codebase. It has over 640 lines and includes decades of heritage with edge cases, new language features, and syntax.

One of the simpler examples would be the part that converts a newline break into a NEWLINE token:

staticinttok_get(structtok_state*tok,char**p_start,char**p_end){.../* Newline */if(c=='\n'){tok->atbol=1;if(blankline||tok->level>0){gotonextline;}*p_start=tok->start;*p_end=tok->cur-1;/* Leave '\n' out of the string */tok->cont_line=0;if(tok->async_def){/* We're somewhere inside an 'async def' function, and               we've encountered a NEWLINE after its signature. */tok->async_def_nl=1;}returnNEWLINE;}...}

In this case,NEWLINE is a token, with a value defined inInclude/token.h. All tokens are constantint values, and theInclude/token.h file was generated earlier when we ranmake regen-grammar.

Thenode type returned byPyParser_ParseFileObject() is going to be essential for the next stage, converting a parse tree into an Abstract-Syntax-Tree (AST):

typedefstruct_node{shortn_type;char*n_str;intn_lineno;intn_col_offset;intn_nchildren;struct_node*n_child;intn_end_lineno;intn_end_col_offset;}node;

Since the CST is a tree of syntax, token IDs, and symbols, it would be difficult for the compiler to make quick decisions based on the Python language.

That is why the next stage is to convert the CST into an AST, a much higher-level structure. This task is performed by thePython/ast.c module, which has both a C and Python API.

Before you jump into the AST, there is a way to access the output from the parser stage. CPython has a standard library moduleparser, which exposes the C functions with a Python API.

The module is documented as an implementation detail of CPython so that you won’t see it in other Python interpreters. Also the output from the functions is not that easy to read.

The output will be in the numeric form, using the token and symbol numbers generated by themake regen-grammar stage, stored inInclude/token.h:

>>>frompprintimportpprint>>>importparser>>>st=parser.expr('a + 1')>>>pprint(parser.st2list(st))[258, [332,  [306,   [310,    [311,     [312,      [313,       [316,        [317,         [318,          [319,           [320,            [321, [322, [323, [324, [325, [1, 'a']]]]]],            [14, '+'],            [321, [322, [323, [324, [325, [2, '1']]]]]]]]]]]]]]]]], [4, ''], [0, '']]

To make it easier to understand, you can take all the numbers in thesymbol andtoken modules, put them into a dictionary andrecursively replace the values in the output ofparser.st2list() with the names:

importsymbolimporttokenimportparserdeflex(expression):symbols={v:kfork,vinsymbol.__dict__.items()ifisinstance(v,int)}tokens={v:kfork,vintoken.__dict__.items()ifisinstance(v,int)}lexicon={**symbols,**tokens}st=parser.expr(expression)st_list=parser.st2list(st)defreplace(l:list):r=[]foriinl:ifisinstance(i,list):r.append(replace(i))else:ifiinlexicon:r.append(lexicon[i])else:r.append(i)returnrreturnreplace(st_list)

You can runlex() with a simple expression, likea + 1 to see how this is represented as a parser-tree:

>>>frompprintimportpprint>>>pprint(lex('a + 1'))['eval_input', ['testlist',  ['test',   ['or_test',    ['and_test',     ['not_test',      ['comparison',       ['expr',        ['xor_expr',         ['and_expr',          ['shift_expr',           ['arith_expr',            ['term',             ['factor', ['power', ['atom_expr', ['atom', ['NAME', 'a']]]]]],            ['PLUS', '+'],            ['term',             ['factor',              ['power', ['atom_expr', ['atom', ['NUMBER', '1']]]]]]]]]]]]]]]]], ['NEWLINE', ''], ['ENDMARKER', '']]

In the output, you can see the symbols in lowercase, such as'test' and the tokens in uppercase, such as'NUMBER'.

Abstract Syntax Trees

The next stage in the CPython interpreter is to convert the CST generated by the parser into something more logical that can be executed. The structure is a higher-level representation of the code, called an Abstract Syntax Tree (AST).

ASTs are produced inline with the CPython interpreter process, but you can also generate them in both Python using theast module in the Standard Library as well as through the C API.

Before diving into the C implementation of the AST, it would be useful to understand what an AST looks like for a simple piece of Python code.

To do this, here’s a simple app calledinstaviz for this tutorial. It displays the AST and bytecode instructions (which we’ll cover later) in a Web UI.

To installinstaviz:

$pipinstallinstaviz

Then, open up a REPL by runningpython at the command line with no arguments:

>>>importinstaviz>>>defexample():       a = 1       b = a + 1       return b>>>instaviz.show(example)

You’ll see a notification on the command-line that a web server has started on port8080. If you were using that port for something else, you can change it by callinginstaviz.show(example, port=9090) or another port number.

In the web browser, you can see the detailed breakdown of your function:

The bottom left graph is the function you declared in REPL, represented as an Abstract Syntax Tree. Each node in the tree is an AST type. They are found in theast module, and all inherit from_ast.AST.

Some of the nodes have properties which link them to child nodes, unlike the CST, which has a generic child node property.

For example, if you click on the Assign node in the center, this links to the lineb = a + 1:

It has two properties:

1. targets is a list of names to assign. It is a list because you can assign to multiple variables with a single expression using unpacking
2. value is the value to assign, which in this case is aBinOp statement,a + 1.

If you click on theBinOp statement, it shows the properties of relevance:

• left: the node to the left of the operator
• op: the operator, in this case, anAdd node (+) for addition
• right: the node to the right of the operator

Compiling an AST in C is not a straightforward task, so thePython/ast.c module is over 5000 lines of code.

There are a few entry points, forming part of the AST’s public API. In the last section on the lexer and parser, you stopped when you’d reached the call toPyAST_FromNodeObject(). By this stage, the Python interpreter process had created a CST in the format ofnode * tree.

Jumping then intoPyAST_FromNodeObject() insidePython/ast.c, you can see it receives thenode * tree, the filename, compiler flags, and thePyArena.

The return type from this function ismod_ty, defined inInclude/Python-ast.h.mod_ty is a container structure for one of the 5 module types in Python:

1. Module
2. Interactive
3. Expression
4. FunctionType
5. Suite

InInclude/Python-ast.h you can see that anExpression type requires a fieldbody, which is anexpr_ty type. Theexpr_ty type is also defined inInclude/Python-ast.h:

enum_mod_kind{Module_kind=1,Interactive_kind=2,Expression_kind=3,FunctionType_kind=4,Suite_kind=5};struct_mod{enum_mod_kindkind;union{struct{asdl_seq*body;asdl_seq*type_ignores;}Module;struct{asdl_seq*body;}Interactive;struct{expr_tybody;}Expression;struct{asdl_seq*argtypes;expr_tyreturns;}FunctionType;struct{asdl_seq*body;}Suite;}v;};

The AST types are all listed inParser/Python.asdl. You will see the module types, statement types, expression types, operators, and comprehensions all listed. The names of the types in this document relate to the classes generated by the AST and the same classes named in theast standard module library.

The parameters and names inInclude/Python-ast.h correlate directly to those specified inParser/Python.asdl:

-- ASDL's 5 builtin types are:-- identifier, int, string, object, constantmodule Python{    mod = Module(stmt* body, type_ignore *type_ignores)        | Interactive(stmt* body)        | Expression(expr body)        | FunctionType(expr* argtypes, expr returns)

The C header file and structures are there so that thePython/ast.c program can quickly generate the structures with pointers to the relevant data.

Looking atPyAST_FromNodeObject() you can see that it is essentially aswitch statement around the result fromTYPE(n).TYPE() is one of the core functions used by the AST to determine what type a node in the concrete syntax tree is. In the case ofPyAST_FromNodeObject() it’s just looking at the first node, so it can only be one of the module types defined asModule,Interactive,Expression,FunctionType.

The result ofTYPE() will be either a symbol or token type, which we’re very familiar with by this stage.

Forfile_input, the results should be aModule. Modules are a series of statements, of which there are a few types. The logic to traverse the children ofn and create statement nodes is withinast_for_stmt(). This function is called either once, if there is only 1 statement in the module, or in a loop if there are many. The resultingModule is then returned with thePyArena.

Foreval_input, the result should be anExpression. The result fromCHILD(n ,0), which is the first child ofn is passed toast_for_testlist() which returns anexpr_ty type. Thisexpr_ty is sent toExpression() with the PyArena to create an expression node, and then passed back as a result:

mod_tyPyAST_FromNodeObject(constnode*n,PyCompilerFlags*flags,PyObject*filename,PyArena*arena){...switch(TYPE(n)){casefile_input:stmts=_Py_asdl_seq_new(num_stmts(n),arena);if(!stmts)gotoout;for(i=0;i<NCH(n)-1;i++){ch=CHILD(n,i);if(TYPE(ch)==NEWLINE)continue;REQ(ch,stmt);num=num_stmts(ch);if(num==1){s=ast_for_stmt(&c,ch);if(!s)gotoout;asdl_seq_SET(stmts,k++,s);}else{ch=CHILD(ch,0);REQ(ch,simple_stmt);for(j=0;j<num;j++){s=ast_for_stmt(&c,CHILD(ch,j*2));if(!s)gotoout;asdl_seq_SET(stmts,k++,s);}}}/* Type ignores are stored under the ENDMARKER in file_input. */...res=Module(stmts,type_ignores,arena);break;caseeval_input:{expr_tytestlist_ast;/* XXX Why not comp_for here? */testlist_ast=ast_for_testlist(&c,CHILD(n,0));if(!testlist_ast)gotoout;res=Expression(testlist_ast,arena);break;}casesingle_input:...break;casefunc_type_input:......returnres;}

Inside theast_for_stmt() function, there is anotherswitch statement for each possible statement type (simple_stmt,compound_stmt, and so on) and the code to determine the arguments to the node class.

One of the simpler functions is for the power expression, i.e.,2**4 is 2 to the power of 4. This function starts by getting theast_for_atom_expr(), which is the number2 in our example, then if that has one child, it returns the atomic expression. If it has more than one child, it will get the right-hand (the number4) and return aBinOp (binary operation) with the operator asPow (power), the left hand ofe (2), and the right hand off (4):

staticexpr_tyast_for_power(structcompiling*c,constnode*n){/* power: atom trailer* ('**' factor)*     */expr_tye;REQ(n,power);e=ast_for_atom_expr(c,CHILD(n,0));if(!e)returnNULL;if(NCH(n)==1)returne;if(TYPE(CHILD(n,NCH(n)-1))==factor){expr_tyf=ast_for_expr(c,CHILD(n,NCH(n)-1));if(!f)returnNULL;e=BinOp(e,Pow,f,LINENO(n),n->n_col_offset,n->n_end_lineno,n->n_end_col_offset,c->c_arena);}returne;}

You can see the result of this if you send a short function to theinstaviz module:

>>>deffoo():       2**4>>>importinstaviz>>>instaviz.show(foo)

In the UI you can also see the corresponding properties:

In summary, each statement type and expression has a correspondingast_for_*() function to create it. The arguments are defined inParser/Python.asdl and exposed via theast module in the standard library. If an expression or statement has children, then it will call the correspondingast_for_* child function in a depth-first traversal.

Conclusion

CPython’s versatility and low-level execution API make it the ideal candidate for an embedded scripting engine. You will see CPython used in many UI applications, such as Game Design, 3D graphics and system automation.

The interpreter process is flexible and efficient, and now you have an understanding of how it works you’re ready to understand the compiler.

Compiling

Now the interpreter has an AST with the properties required for each of the operations, functions, classes, and namespaces. It is the job of the compiler to turn the AST into something the CPU can understand.

This compilation task is split into 2 parts:

1. Traverse the tree and create a control-flow-graph, which represents the logical sequence for execution
2. Convert the nodes in the CFG to smaller, executable statements, known as byte-code

Earlier, we were looking at how files are executed, and thePyRun_FileExFlags() function inPython/pythonrun.c. Inside this function, we converted theFILE handle into amod, of typemod_ty. This task was completed byPyParser_ASTFromFileObject(), which in turns calls thetokenizer,parser-tokenizer and then the AST:

PyObject*PyRun_FileExFlags(FILE*fp,constchar*filename_str,intstart,PyObject*globals,PyObject*locals,intcloseit,PyCompilerFlags*flags){...mod=PyParser_ASTFromFileObject(fp,filename,NULL,start,0,0,...ret=run_mod(mod,filename,globals,locals,flags,arena);}

The resulting module from the call to is sent torun_mod() still inPython/pythonrun.c. This is a small function that gets aPyCodeObject fromPyAST_CompileObject() and sends it on torun_eval_code_obj(). You will tacklerun_eval_code_obj() in the next section:

staticPyObject*run_mod(mod_tymod,PyObject*filename,PyObject*globals,PyObject*locals,PyCompilerFlags*flags,PyArena*arena){PyCodeObject*co;PyObject*v;co=PyAST_CompileObject(mod,filename,flags,-1,arena);if(co==NULL)returnNULL;if(PySys_Audit("exec","O",co)<0){Py_DECREF(co);returnNULL;}v=run_eval_code_obj(co,globals,locals);Py_DECREF(co);returnv;}

ThePyAST_CompileObject() function is the main entry point to the CPython compiler. It takes a Python module as its primary argument, along with the name of the file, the globals, locals, and thePyArena all created earlier in the interpreter process.

We’re starting to get into the guts of the CPython compiler now, with decades of development and Computer Science theory behind it. Don’t be put off by the language. Once we break down the compiler into logical steps, it’ll make sense.

Before the compiler starts, a global compiler state is created. This type,compiler is defined inPython/compile.c and contains properties used by the compiler to remember the compiler flags, the stack, and thePyArena:

structcompiler{PyObject*c_filename;structsymtable*c_st;PyFutureFeatures*c_future;/* pointer to module's __future__ */PyCompilerFlags*c_flags;intc_optimize;/* optimization level */intc_interactive;/* true if in interactive mode */intc_nestlevel;intc_do_not_emit_bytecode;/* The compiler won't emit any bytecode                                    if this value is different from zero.                                    This can be used to temporarily visit                                    nodes without emitting bytecode to                                    check only errors. */PyObject*c_const_cache;/* Python dict holding all constants,                                    including names tuple */structcompiler_unit*u;/* compiler state for current block */PyObject*c_stack;/* Python list holding compiler_unit ptrs */PyArena*c_arena;/* pointer to memory allocation arena */};

InsidePyAST_CompileObject(), there are 11 main steps happening:

1. Create an empty__doc__ property to the module if it doesn’t exist.
2. Create an empty__annotations__ property to the module if it doesn’t exist.
3. Set the filename of the global compiler state to the filename argument.
4. Set the memory allocation arena for the compiler to the one used by the interpreter.
5. Copy any__future__ flags in the module to the future flags in the compiler.
6. Merge runtime flags provided by the command-line or environment variables.
7. Enable any__future__ features in the compiler.
8. Set the optimization level to the provided argument, or default.
9. Build a symbol table from the module object.
10. Run the compiler with the compiler state and return the code object.
11. Free any allocated memory by the compiler.

PyCodeObject*PyAST_CompileObject(mod_tymod,PyObject*filename,PyCompilerFlags*flags,intoptimize,PyArena*arena){structcompilerc;PyCodeObject*co=NULL;PyCompilerFlagslocal_flags=_PyCompilerFlags_INIT;intmerged;PyConfig*config=&_PyInterpreterState_GET_UNSAFE()->config;if(!__doc__){__doc__=PyUnicode_InternFromString("__doc__");if(!__doc__)returnNULL;}if(!__annotations__){__annotations__=PyUnicode_InternFromString("__annotations__");if(!__annotations__)returnNULL;}if(!compiler_init(&c))returnNULL;Py_INCREF(filename);c.c_filename=filename;c.c_arena=arena;c.c_future=PyFuture_FromASTObject(mod,filename);if(c.c_future==NULL)gotofinally;if(!flags){flags=&local_flags;}merged=c.c_future->ff_features|flags->cf_flags;c.c_future->ff_features=merged;flags->cf_flags=merged;c.c_flags=flags;c.c_optimize=(optimize==-1)?config->optimization_level:optimize;c.c_nestlevel=0;c.c_do_not_emit_bytecode=0;if(!_PyAST_Optimize(mod,arena,c.c_optimize)){gotofinally;}c.c_st=PySymtable_BuildObject(mod,filename,c.c_future);if(c.c_st==NULL){if(!PyErr_Occurred())PyErr_SetString(PyExc_SystemError,"no symtable");gotofinally;}co=compiler_mod(&c,mod);finally:compiler_free(&c);assert(co||PyErr_Occurred());returnco;}

from__future__importannotations

structsymtable{PyObject*st_filename;/* name of file being compiled,                                       decoded from the filesystem encoding */struct_symtable_entry*st_cur;/* current symbol table entry */struct_symtable_entry*st_top;/* symbol table entry for module */PyObject*st_blocks;/* dict: map AST node addresses                                     *       to symbol table entries */PyObject*st_stack;/* list: stack of namespace info */PyObject*st_global;/* borrowed ref to st_top->ste_symbols */intst_nblocks;/* number of blocks used. kept for                                       consistency with the corresponding                                       compiler structure */PyObject*st_private;/* name of current class or NULL */PyFutureFeatures*st_future;/* module's future features that affect                                       the symbol table */intrecursion_depth;/* current recursion depth */intrecursion_limit;/* recursion limit */};

>>>importsymtable>>>s=symtable.symtable('b + 1',filename='test.py',compile_type='eval')>>>[symbol.__dict__forsymbolins.get_symbols()][{'_Symbol__name': 'b', '_Symbol__flags': 6160, '_Symbol__scope': 3, '_Symbol__namespaces': ()}]

structsymtable*PySymtable_BuildObject(mod_tymod,PyObject*filename,PyFutureFeatures*future){structsymtable*st=symtable_new();asdl_seq*seq;inti;PyThreadState*tstate;intrecursion_limit=Py_GetRecursionLimit();...st->st_top=st->st_cur;switch(mod->kind){caseModule_kind:seq=mod->v.Module.body;for(i=0;i<asdl_seq_LEN(seq);i++)if(!symtable_visit_stmt(st,(stmt_ty)asdl_seq_GET(seq,i)))gotoerror;break;caseExpression_kind:...caseInteractive_kind:...caseSuite_kind:...caseFunctionType_kind:...}...}

staticintsymtable_visit_stmt(structsymtable*st,stmt_tys){if(++st->recursion_depth>st->recursion_limit){// 1.PyErr_SetString(PyExc_RecursionError,"maximum recursion depth exceeded during compilation");VISIT_QUIT(st,0);}switch(s->kind){caseFunctionDef_kind:if(!symtable_add_def(st,s->v.FunctionDef.name,DEF_LOCAL))// 2.VISIT_QUIT(st,0);if(s->v.FunctionDef.args->defaults)// 3.VISIT_SEQ(st,expr,s->v.FunctionDef.args->defaults);if(s->v.FunctionDef.args->kw_defaults)// 4.VISIT_SEQ_WITH_NULL(st,expr,s->v.FunctionDef.args->kw_defaults);if(!symtable_visit_annotations(st,s,s->v.FunctionDef.args,// 5.s->v.FunctionDef.returns))VISIT_QUIT(st,0);if(s->v.FunctionDef.decorator_list)// 6.VISIT_SEQ(st,expr,s->v.FunctionDef.decorator_list);if(!symtable_enter_block(st,s->v.FunctionDef.name,// 7.FunctionBlock,(void*)s,s->lineno,s->col_offset))VISIT_QUIT(st,0);VISIT(st,arguments,s->v.FunctionDef.args);// 8.VISIT_SEQ(st,stmt,s->v.FunctionDef.body);// 9.if(!symtable_exit_block(st,s))VISIT_QUIT(st,0);break;caseClassDef_kind:{...}caseReturn_kind:...caseDelete_kind:...caseAssign_kind:...caseAnnAssign_kind:...

>>>compile('b+1','test.py',mode='eval')<code object <module> at 0x10f222780, file "test.py", line 1>

>>>co.co_codeb'e\x00d\x00\x17\x00S\x00'

>>>importdis>>>dis.dis(co.co_code)          0 LOAD_NAME                0 (0)          2 LOAD_CONST               0 (0)          4 BINARY_ADD          6 RETURN_VALUE

>>>importinstaviz>>>defexample():       a = 1       b = a + 1       return b>>>instaviz.show(example)

staticPyCodeObject*compiler_mod(structcompiler*c,mod_tymod){PyCodeObject*co;intaddNone=1;staticPyObject*module;...switch(mod->kind){caseModule_kind:if(!compiler_body(c,mod->v.Module.body)){compiler_exit_scope(c);return0;}break;caseInteractive_kind:...caseExpression_kind:...caseSuite_kind:......co=assemble(c,addNone);compiler_exit_scope(c);returnco;}

staticintcompiler_body(structcompiler*c,asdl_seq*stmts){inti=0;stmt_tyst;PyObject*docstring;...for(;i<asdl_seq_LEN(stmts);i++)VISIT(c,stmt,(stmt_ty)asdl_seq_GET(stmts,i));return1;}

#define VISIT(C, TYPE, V) {\    if (!compiler_visit_ ## TYPE((C), (V))) \        return 0; \}

staticintcompiler_visit_stmt(structcompiler*c,stmt_tys){Py_ssize_ti,n;/* Always assign a lineno to the next instruction for a stmt. */c->u->u_lineno=s->lineno;c->u->u_col_offset=s->col_offset;c->u->u_lineno_set=0;switch(s->kind){caseFunctionDef_kind:returncompiler_function(c,s,0);caseClassDef_kind:returncompiler_class(c,s);...caseFor_kind:returncompiler_for(c,s);...}return1;}