Introduction to IronPython Compiler

Since the official release of IronPython, I have been driven by my love for the Python language. At the same time, I want to learn how IronPython compiler, analyzer, and other programs of the programming language work, so I started learning the IronPython compiler.

However, the Code has been read for a while. I used to look at some implementation details, and the results become more and more confused. Now I find that we need to change the strategy, because we understand that a system always starts to understand its usage. If we directly understand the underlying operating principles, it may be lost in the Code ocean. So I am also preparing to take the top-down analysis method, pick up the soft persimmon, and start from a simple, Macro. The specific implementation details can be further studied.

Go straight to the topic. We can see the Compile () method, which is the main control method for compilation. This method is not hard to understand. I read it again, and the notes are as follows:

 
 

  
  
///<Summary> 
  
  
/// Compile
  
  
///</Summary> 
  
  
Public void Compile (){
  
  
StringFullPath= Path. GetFullPath (outputAssembly );
  
  
StringOutDir=Path. GetDirectoryName (fullPath );
  
  
StringFileName=Path. GetFileName (outputAssembly );
  
  
 
  
  
// The acceptance pool of the Python Compiler
  
  
PythonCompilerSinkSink=NewPythonCompilerSink (compilerSink );
  
  
 
  
  
// Assembly Generator
  
  
AssemblyGen=NewAssemblyGen (
  
  
Path. GetFileNameWithoutExtension (outputAssembly ),
  
  
OutDir, fileName, includeDebugInformation, staticTypes, executable, machine
  
  
);
  
  
 
  
  
// Whether to set the entry point)
  
  
BoolEntryPointSet=False;
  
  
 
  
  
// Set the default main file type for non-DLL output files)
  
  
If (MainFile= Null &&SourceFiles. Count= 1 & targetKind! = PEFileKinds. Dll ){
  
  
MainFile=SourceFiles[0];
  
  
}
  
  
 
  
  
// Compile each source file in sequence
  
  
Foreach (string sourceFile in sourceFiles ){
  
  
// Whether the Main method is generated
  
  
BoolCreateMainMethod=SourceFile= MainFile;
  
  
// Each source code file is compiled into a module
  
  
CompilePythonModule (sourceFile, sink, createMainMethod );
  
  
 
  
  
If (sink. Errors>0) return;
  
  
 
  
  
If (createMainMethod ){
  
  
EntryPointSet=True;
  
  
}
  
  
}
 
 

In this Code, the private method CompilePythonModule () of the IronPython compiler is called to compile the module. Next let's take a look at what this method is doing:

 
 

  
  
// Add all resource files to the Assembly in sequence
  
  
If (resourceFiles! = Null ){
  
  
Foreach (ResourceFile rf in resourceFiles ){
  
  
AssemblyGen. AddResourceFile (rf. Name, rf. File, rf. PublicResource? ResourceAttributes. Public: ResourceAttributes. Private );
  
  
}
  
  
}
  
  
 
  
  
// For non-DLL target files, there must be an entry point
  
  
If (targetKind! = PEFileKinds. Dll &&! EntryPointSet ){
  
  
Sink. addError ("", string. format ("Need an entry point for target kind {0}", targetKind), String. empty, CodeSpan. empty,-1, Severity. error );
  
  
}
  
  
 
  
  
// The final output assembly
  
  
AssemblyGen. Dump ();
  
  
}
  
  
 
  
  
This article from the CSDN blog, reproduced please indicate the source: http://blog.csdn.net/inelm/archive/2006/10/09/4612996.aspx
 
 

In the above two methods, we can see that there are several important classes which will be the key clues for our next analysis:

 
 

  
  
// Compile the module
  
  
Private void CompilePythonModule (string fileName, PythonCompilerSink, bool createMain ){
  
  
// Set the source file to be compiled
  
  
AssemblyGen. SetPythonSourceFile (fileName );
  
  
// Create a compiler environment object
  
  
CompilerContextContext=NewCompilerContext (fileName, sink );
  
  
// Create a Analyzer
  
  
ParserP=Parser. FromFile (state, context );
  
  
// Call the analyzer analysis method to obtain a statement object statement that uses the nested concept of the combination mode. This statement represents a large statement in the entire file)
  
  
StatementBody=P. ParseFileInput ();
  
  
 
  
  
If (sink. Errors>0) return;
  
  
 
  
  
// Create a global suite ?? It may be the dictionary object globals. To be analyzed...
  
  
// What is the Binder here.
  
  
GlobalSuiteGs=Compiler. Ast. Binder. Bind (body, context );
  
  
StringModuleName=GetModuleFromFilename(FileName );
  
  
// Here we see TypeGen, which represents a Type Generator
  
  
// Tg points to a module type IronPython, and each module is generated as a corresponding class .)
  
  
TypeGenTg=OutputGenerator. GenerateModuleType (moduleName, assemblyGen );
  
  
// Compile the _ init _ method of the module ?? Guess)
  
  
CodeGenInit=CompileModuleInit(Context, gs, tg, moduleName );
 
 

So far, we have seen the IronPython compiler workflow, starting from a series of source code files, resource files, and other configuration attributes, through the operations of Parser and various Generator, the Dump () method of AssemblyGenerator is finally reached, and the compilation result assembly is output.

1. How to embed Python into C ++ applications?
2. In-depth discussion of Ruby and Python syntax comparison
3. Introduction to Python
4. Python Learning Experience: version, IDE selection and coding Solutions
5. Analysis of Python GIL and thread security