LCD Screens in python

Merge with python branch

.clang-format

@@ -4,9 +4,11 @@ IndentWidth: 4
 ---
 Language: Cpp
 AlignEscapedNewlinesLeft: true
+AlignTrailingComments: false
 BreakBeforeBraces: Allman
 BreakBeforeTernaryOperators: false
 AllowShortBlocksOnASingleLine: false
 AllowShortIfStatementsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
 ColumnLimit: 100
 ---

AdvSound.cpp

@@ -32,10 +32,12 @@ TAdvancedSound::~TAdvancedSound()
     // SoundShut.Stop();
 }
 
-void TAdvancedSound::Free() {}
+void TAdvancedSound::Free()
+{
+}
 
-void TAdvancedSound::Init(char *NameOn, char *Name, char *NameOff,
+void TAdvancedSound::Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation,
-                                     double DistanceAttenuation, vector3 pPosition)
+                          vector3 pPosition)
 {
     SoundStart.Init(NameOn, DistanceAttenuation, pPosition.x, pPosition.y, pPosition.z, true);
     SoundCommencing.Init(Name, DistanceAttenuation, pPosition.x, pPosition.y, pPosition.z, true);
@@ -131,8 +133,7 @@ void TAdvancedSound::Update(bool ListenerInside, vector3 NewPosition)
     }
 }
 
-void TAdvancedSound::UpdateAF(double A, double F, bool ListenerInside,
+void TAdvancedSound::UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition)
-                                         vector3 NewPosition)
 { // update, ale z amplituda i czestotliwoscia
     if ((State == ss_Commencing) && (SoundCommencing.AM > 0))
     {

AirCoupler.cpp

@@ -14,9 +14,14 @@ http://mozilla.org/MPL/2.0/.
 #include "AirCoupler.h"
 #include "Timer.h"
 
-TAirCoupler::TAirCoupler() { Clear(); }
+TAirCoupler::TAirCoupler()
+{
+    Clear();
+}
 
-TAirCoupler::~TAirCoupler() {}
+TAirCoupler::~TAirCoupler()
+{
+}
 
 int TAirCoupler::GetStatus()
 { // zwraca 1, jeœli istnieje model prosty, 2 gdy skoœny

AnimModel.cpp

@@ -28,6 +28,7 @@ http://mozilla.org/MPL/2.0/.
 //---------------------------------------------------------------------------
 
 TAnimAdvanced::TAnimAdvanced(){};
+
 TAnimAdvanced::~TAnimAdvanced(){
     // delete[] pVocaloidMotionData; //plik został zmodyfikowany
 };
@@ -684,10 +685,12 @@ void TAnimModel::RenderAlphaVBO(vector3 *vPosition)
 //---------------------------------------------------------------------------
 bool TAnimModel::TerrainLoaded()
 { // zliczanie kwadratów kilometrowych (główna linia po Next) do tworznia tablicy
-  return (this ? pModel != NULL : false); };
+    return (this ? pModel != NULL : false);
+};
 int TAnimModel::TerrainCount()
 { // zliczanie kwadratów kilometrowych (główna linia po Next) do tworznia tablicy
-  return pModel ? pModel->TerrainCount() : 0; };
+    return pModel ? pModel->TerrainCount() : 0;
+};
 TSubModel *__fastcall TAnimModel::TerrainSquare(int n)
 { // pobieranie wskaźników do pierwszego submodelu
     return pModel ? pModel->TerrainSquare(n) : 0;

AnimModel.h

@@ -80,7 +80,10 @@ class TAnimContainer
     // std::string(pSubModel?pSubModel->asName.c_str():""); };
     // std::string inline GetName() { return std::string(pSubModel?pSubModel->pName:"");
     // };
-    char *__fastcall NameGet() { return (pSubModel ? pSubModel->pName : NULL); };
+    char *__fastcall NameGet()
+    {
+        return (pSubModel ? pSubModel->pName : NULL);
+    };
     // void SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double
     // fNewRotateSpeed, bool bResetAngle=false);
     void SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed);
@@ -90,7 +93,10 @@ class TAnimContainer
     void UpdateModel();
     void UpdateModelIK();
     bool InMovement(); // czy w trakcie animacji?
-    double _fastcall AngleGet() { return vRotateAngles.z; }; // jednak ostatnia, T3D ma inny uk³ad
+    double _fastcall AngleGet()
+    {
+        return vRotateAngles.z;
+    }; // jednak ostatnia, T3D ma inny uk³ad
     vector3 _fastcall TransGet()
     {
         return vector3(-vTranslation.x, vTranslation.z, vTranslation.y);
@@ -101,7 +107,10 @@ class TAnimContainer
             pSubModel->WillBeAnimated();
     };
     void EventAssign(TEvent *ev);
-    TEvent *__fastcall Event() { return evDone; };
+    TEvent *__fastcall Event()
+    {
+        return evDone;
+    };
 };
 
 class TAnimAdvanced

Button.h

@@ -25,7 +25,10 @@ class TButton
     TButton();
     ~TButton();
     void Clear(int i = -1);
-    inline void FeedbackBitSet(int i) { iFeedbackBit = 1 << i; };
+    inline void FeedbackBitSet(int i)
+    {
+        iFeedbackBit = 1 << i;
+    };
     inline void Turn(bool to)
     {
         bOn = to;
@@ -46,7 +49,10 @@ class TButton
         bOn = !bOn;
         Update();
     };
-    inline bool Active() { return (pModelOn) || (pModelOff); };
+    inline bool Active()
+    {
+        return (pModelOn) || (pModelOff);
+    };
     void Init(AnsiString asName, TModel3d *pModel, bool bNewOn = false);
     void Load(TQueryParserComp *Parser, TModel3d *pModel1, TModel3d *pModel2 = NULL);
 };

Camera.h

@@ -38,7 +38,10 @@ class TCamera
     vector3 CrossPos;
     double CrossDist;
     void Init(vector3 NPos, vector3 NAngle);
-    void Reset() { Pitch = Yaw = Roll = 0; };
+    void Reset()
+    {
+        Pitch = Yaw = Roll = 0;
+    };
     void OnCursorMove(double x, double y);
     void Update();
     vector3 GetDirection();

Console.cpp

@@ -274,7 +274,10 @@ void Console::BitsUpdate(int mask)
     }
 };
 
-bool Console::Pressed(int x) { return Global::bActive && (GetKeyState(x) < 0); }; // na razie tak - czyta się tylko klawiatura 
+bool Console::Pressed(int x)
+{ // na razie tak - czyta się tylko klawiatura
+    return Global::bActive && (GetKeyState(x) < 0);
+};
 
 void Console::ValueSet(int x, double y)
 { // ustawienie wartości (y) na kanale analogowym (x)
@@ -353,5 +356,11 @@ void Console::OnKeyUp(int k)
         else
             iButton[char(k) >> 5] &= ~(1 << (k & 31)); // wyłącz monostabilny podstawowy
 };
-int Console::KeyDownConvert(int k) { return int(ktTable[k & 0x3FF].iDown); };
+int Console::KeyDownConvert(int k)
-int Console::KeyUpConvert(int k) { return int(ktTable[k & 0x3FF].iUp); };
+{
+    return int(ktTable[k & 0x3FF].iDown);
+};
+int Console::KeyUpConvert(int k)
+{
+    return int(ktTable[k & 0x3FF].iUp);
+};

Console/LPT.cpp

@@ -48,4 +48,7 @@ bool TLPT::Connect(int port)
     return bool(OutPort);
 };
 
-void TLPT::Out(int x) { OutPort(address, x); }; // wys³anie bajtu do portu
+void TLPT::Out(int x)
+{ // wys³anie bajtu do portu
+    OutPort(address, x);
+};

Console/PoKeys55.cpp

@@ -39,7 +39,10 @@ TPoKeys55::TPoKeys55()
     bNoError = true;
 };
 //---------------------------------------------------------------------------
-TPoKeys55::~TPoKeys55() { Close(); };
+TPoKeys55::~TPoKeys55()
+{
+    Close();
+};
 //---------------------------------------------------------------------------
 bool TPoKeys55::Close()
 { // roz³¹czenie komunikacji
@@ -202,8 +205,7 @@ bool TPoKeys55::Connect()
     return false;
 }
 //---------------------------------------------------------------------------
-bool TPoKeys55::Write(unsigned char c, unsigned char b3, unsigned char b4,
+bool TPoKeys55::Write(unsigned char c, unsigned char b3, unsigned char b4, unsigned char b5)
-                                 unsigned char b5)
 {
     DWORD BytesWritten = 0;
     OutputBuffer[0] = 0; // The first byte is the "Report ID" and does not get transmitted over the

Console/PoKeys55.h

@@ -28,8 +28,7 @@ class TPoKeys55
     ~TPoKeys55();
     bool Connect();
     bool Close();
-    bool Write(unsigned char c, unsigned char b3, unsigned char b4 = 0,
+    bool Write(unsigned char c, unsigned char b3, unsigned char b4 = 0, unsigned char b5 = 0);
-                          unsigned char b5 = 0);
     bool Read();
     bool ReadLoop(int i);
     AnsiString Version();

Data.h

@@ -17,7 +17,8 @@ struct TDist
 {
     int x, y;
 };
-const TDist SectorOrder[] = { // tabela wspó³rzêdnych sektorów, posortowana wg odleg³oœci
+const TDist SectorOrder[] = {
+    // tabela wspó³rzêdnych sektorów, posortowana wg odleg³oœci
     {0, 0}, // 0.00
     {1, 0}, // 1.00
     {0, 1}, // 1.00

Driver.cpp

@@ -87,7 +87,8 @@ const double HardAcceleration = 0.9;
 const double PrepareTime = 2.0; //[s] przebłyski świadomości przy odpalaniu
 bool WriteLogFlag = false;
 
-AnsiString StopReasonTable[] = { // przyczyny zatrzymania ruchu AI
+AnsiString StopReasonTable[] = {
+    // przyczyny zatrzymania ruchu AI
     "", // stopNone, //nie ma powodu - powinien jechać
     "Off", // stopSleep, //nie został odpalony, to nie pojedzie
     "Semaphore", // stopSem, //semafor zamknięty
@@ -624,8 +625,7 @@ void TController::TableCheck(double fDistance)
     }
 };
 
-TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fNext,
+TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fNext, double &fAcc)
-                                                 double &fAcc)
 { // ustalenie parametrów, zwraca typ komendy, jeśli sygnał podaje prędkość do jazdy
     // fVelDes - prędkość zadana
     // fDist - dystans w jakim należy rozważyć ruch
@@ -4564,9 +4564,15 @@ void TController::OrdersDump()
     }
 };
 
-TOrders TController::OrderCurrentGet() { return OrderList[OrderPos]; }
+TOrders TController::OrderCurrentGet()
+{
+    return OrderList[OrderPos];
+}
 
-TOrders TController::OrderNextGet() { return OrderList[OrderPos + 1]; }
+TOrders TController::OrderNextGet()
+{
+    return OrderList[OrderPos + 1];
+}
 
 void TController::OrdersInit(double fVel)
 { // wypełnianie tabelki rozkazów na podstawie rozkładu
@@ -5054,15 +5060,30 @@ void TController::DirectionForward(bool forward)
                 mvControlling->IncMainCtrl(1); //żeby nie zgasł
 };
 
-AnsiString TController::Relation() { return TrainParams->ShowRelation(); }; // zwraca relację pociągu
+AnsiString TController::Relation()
+{ // zwraca relację pociągu
+    return TrainParams->ShowRelation();
+};
 
-AnsiString TController::TrainName() { return TrainParams->TrainName; }; // zwraca relację pociągu
+AnsiString TController::TrainName()
+{ // zwraca relację pociągu
+    return TrainParams->TrainName;
+};
 
-int TController::StationCount() { return TrainParams->StationCount; }; // zwraca ilość stacji (miejsc zatrzymania)
+int TController::StationCount()
+{ // zwraca ilość stacji (miejsc zatrzymania)
+    return TrainParams->StationCount;
+};
 
-int TController::StationIndex() { return TrainParams->StationIndex; }; // zwraca indeks aktualnej stacji (miejsca zatrzymania)
+int TController::StationIndex()
+{ // zwraca indeks aktualnej stacji (miejsca zatrzymania)
+    return TrainParams->StationIndex;
+};
 
-bool TController::IsStop() { return TrainParams->IsStop(); }; // informuje, czy jest zatrzymanie na najbliższej stacji
+bool TController::IsStop()
+{ // informuje, czy jest zatrzymanie na najbliższej stacji
+    return TrainParams->IsStop();
+};
 
 void TController::MoveTo(TDynamicObject *to)
 { // przesunięcie AI do innego pojazdu (przy zmianie kabiny)

Driver.h

@@ -268,7 +268,10 @@ class TController
     void ControllingSet(); // znajduje człon do sterowania
     void AutoRewident(); // ustawia hamulce w składzie
   public:
-    Mtable::TTrainParameters *__fastcall Timetable() { return TrainParams; };
+    Mtable::TTrainParameters *__fastcall Timetable()
+    {
+        return TrainParams;
+    };
     void PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
                     const _mover::TLocation &NewLocation, TStopReason reason = stopComm);
     bool PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
@@ -319,8 +322,7 @@ class TController
     TEvent *__fastcall TableCheckTrackEvent(double fDirection, TTrack *Track);
     void TableTraceRoute(double fDistance, TDynamicObject *pVehicle = NULL);
     void TableCheck(double fDistance);
-    TCommandType TableUpdate(double &fVelDes, double &fDist, double &fNext,
+    TCommandType TableUpdate(double &fVelDes, double &fDist, double &fNext, double &fAcc);
-                                        double &fAcc);
     void TablePurger();
 
   private: // Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
@@ -342,8 +344,14 @@ class TController
     int StationCount();
     int StationIndex();
     bool IsStop();
-    bool Primary() { return this ? bool(iDrivigFlags & movePrimary) : false; };
+    bool Primary()
-    int inline DrivigFlags() { return iDrivigFlags; };
+    {
+        return this ? bool(iDrivigFlags & movePrimary) : false;
+    };
+    int inline DrivigFlags()
+    {
+        return iDrivigFlags;
+    };
     void MoveTo(TDynamicObject *to);
     void DirectionInitial();
     AnsiString TableText(int i);

DynObj.cpp

@@ -131,7 +131,8 @@ TAnim::~TAnim()
         break;
     }
 };
-void TAnim::Parovoz(){// animowanie tłoka i rozrządu parowozu
+void TAnim::Parovoz(){
+    // animowanie tłoka i rozrządu parowozu
 };
 //---------------------------------------------------------------------------
 TDynamicObject *__fastcall TDynamicObject::FirstFind(int &coupler_nr)
@@ -288,7 +289,10 @@ TDynamicObject* TDynamicObject::GetFirstCabDynamic(int cpl_type)
 };
 */
 
-void TDynamicObject::ABuSetModelShake(vector3 mShake) { modelShake = mShake; };
+void TDynamicObject::ABuSetModelShake(vector3 mShake)
+{
+    modelShake = mShake;
+};
 
 int TDynamicObject::GetPneumatic(bool front, bool red)
 {

DynObj.h

@@ -338,14 +338,26 @@ class TDynamicObject
     TDynamicObject *__fastcall Next();
     TDynamicObject *__fastcall NextC(int C);
     double NextDistance(double d = -1.0);
-    void SetdMoveLen(double dMoveLen) { MoverParameters->dMoveLen = dMoveLen; }
+    void SetdMoveLen(double dMoveLen)
-    void ResetdMoveLen() { MoverParameters->dMoveLen = 0; }
+    {
-    double GetdMoveLen() { return MoverParameters->dMoveLen; }
+        MoverParameters->dMoveLen = dMoveLen;
+    }
+    void ResetdMoveLen()
+    {
+        MoverParameters->dMoveLen = 0;
+    }
+    double GetdMoveLen()
+    {
+        return MoverParameters->dMoveLen;
+    }
 
     int GetPneumatic(bool front, bool red);
     void SetPneumatic(bool front, bool red);
     AnsiString asName;
-    AnsiString GetName() { return this ? asName : AnsiString(""); };
+    AnsiString GetName()
+    {
+        return this ? asName : AnsiString("");
+    };
 
     TRealSound rsDiesielInc; // youBy
     TRealSound rscurve; // youBy
@@ -395,7 +407,10 @@ class TDynamicObject
     void Render();
     void RenderAlpha();
     void RenderSounds();
-    inline vector3 GetPosition() { return vPosition; };
+    inline vector3 GetPosition()
+    {
+        return vPosition;
+    };
     inline vector3 HeadPosition()
     {
         return vCoulpler[iDirection ^ 1];
@@ -408,13 +423,34 @@ class TDynamicObject
     {
         return iAxleFirst ? Axle1.pPosition : Axle0.pPosition;
     };
-    inline vector3 VectorFront() { return vFront; };
+    inline vector3 VectorFront()
-    inline vector3 VectorUp() { return vUp; };
+    {
-    inline vector3 VectorLeft() { return vLeft; };
+        return vFront;
-    inline double *__fastcall Matrix() { return mMatrix.getArray(); };
+    };
-    inline double GetVelocity() { return MoverParameters->Vel; };
+    inline vector3 VectorUp()
-    inline double GetLength() { return MoverParameters->Dim.L; };
+    {
-    inline double GetWidth() { return MoverParameters->Dim.W; };
+        return vUp;
+    };
+    inline vector3 VectorLeft()
+    {
+        return vLeft;
+    };
+    inline double *__fastcall Matrix()
+    {
+        return mMatrix.getArray();
+    };
+    inline double GetVelocity()
+    {
+        return MoverParameters->Vel;
+    };
+    inline double GetLength()
+    {
+        return MoverParameters->Dim.L;
+    };
+    inline double GetWidth()
+    {
+        return MoverParameters->Dim.W;
+    };
     inline TTrack *__fastcall GetTrack()
     {
         return (iAxleFirst ? Axle1.GetTrack() : Axle0.GetTrack());
@@ -422,8 +458,7 @@ class TDynamicObject
     // void UpdatePos();
 
     // McZapkie-260202
-    void LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName,
+    void LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName, AnsiString ReplacableSkin);
-                                   AnsiString ReplacableSkin);
 
     inline double ABuGetDirection() // ABu.
     {

EU07.bpr

@@ -13,13 +13,13 @@
       TractionPower.obj parser.obj sky.obj AirCoupler.obj opengl\glew.obj 
       ResourceManager.obj VBO.obj TextureDDS.obj opengl\ARB_Multisample.obj 
       Float3d.obj Classes.obj Driver.obj Names.obj Console.obj Mover.obj 
-      Console\PoKeys55.obj Forth.obj Console\LPT.obj"/>
+      Console\PoKeys55.obj Forth.obj Console\LPT.obj PyInt.obj"/>
     <RESFILES value="EU07.res"/>
     <IDLFILES value=""/>
     <IDLGENFILES value=""/>
     <DEFFILE value=""/>
     <RESDEPEN value="$(RESFILES)"/>
-    <LIBFILES value="opengl\glut32.lib DirectX\Dsound.lib"/>
+    <LIBFILES value="opengl\glut32.lib omf_python27.lib DirectX\Dsound.lib"/>
     <LIBRARIES value="dclocx50.bpi bcbsmp50.bpi VCLX50.lib bcbsmp50.lib Vcl50.lib"/>
     <SPARELIBS value="Vcl50.lib bcbsmp50.lib VCLX50.lib bcbsmp50.bpi dclocx50.bpi"/>
     <PACKAGES value="Vcl50.bpi Vclx50.bpi"/>
@@ -33,8 +33,8 @@
     <USERDEFINES value="GLEW_STATIC;_DEBUG"/>
     <SYSDEFINES value="NO_STRICT;_RTLDLL"/>
     <MAINSOURCE value="EU07.cpp"/>
-    <INCLUDEPATH value="Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl"/>
+    <INCLUDEPATH value="Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl;python\include"/>
-    <LIBPATH value="Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib"/>
+    <LIBPATH value="Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib;python\libs"/>
     <WARNINGS value="-w-par"/>
   </MACROS>
   <OPTIONS>
@@ -58,8 +58,8 @@ IncludeVerInfo=1
 AutoIncBuild=0
 MajorVer=15
 MinorVer=3
-Release=1167
+Release=1168
-Build=470
+Build=471
 Debug=1
 PreRelease=0
 Special=0
@@ -71,8 +71,8 @@ CodePage=1250
 [Version Info Keys]
 CompanyName=EU07 Team
 FileDescription=MaSzyna EU07-424
-FileVersion=15.3.1167.470
+FileVersion=15.3.1168.471
-InternalName=9th by firleju + SPKS + MP
+InternalName=9th by firleju + SPKS + MP + python
 LegalCopyright=
 LegalTrademarks=
 OriginalFilename=eu07.exe
@@ -81,12 +81,14 @@ ProductVersion=15.3
 Comments=
 
 [HistoryLists\hlIncludePath]
-Count=1
+Count=2
-Item0=Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl
+Item0=Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl;python\include
+Item1=Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl
 
 [HistoryLists\hlLibraryPath]
-Count=1
+Count=2
-Item0=Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib
+Item0=Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib;python\libs
+Item1=Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib
 
 [HistoryLists\hlDebugSourcePath]
 Count=2

EU07.cpp

@@ -33,6 +33,7 @@ USEUNIT("Camera.cpp");
 USEUNIT("Texture.cpp");
 USEUNIT("World.cpp");
 USELIB("opengl\glut32.lib");
+USELIB("omf_python27.lib");
 USEUNIT("Model3d.cpp");
 USEUNIT("MdlMngr.cpp");
 USEUNIT("Train.cpp");
@@ -80,6 +81,7 @@ USEUNIT("McZapkie\hamulce.pas");
 USEUNIT("Console\PoKeys55.cpp");
 USEUNIT("Forth.cpp");
 USEUNIT("Console\LPT.cpp");
+USEUNIT("PyInt.cpp");
 //---------------------------------------------------------------------------
 #include "World.h"
 
@@ -754,6 +756,3 @@ int WINAPI WinMain(HINSTANCE hInstance, // instance
     KillGLWindow(); // kill the window
     return (msg.wParam); // exit the program
 }
-
-
-

EvLaunch.cpp

@@ -43,9 +43,14 @@ TEventLauncher::TEventLauncher()
     iCheckMask = 0;
 }
 
-TEventLauncher::~TEventLauncher() { SafeDeleteArray(szText); }
+TEventLauncher::~TEventLauncher()
+{
+    SafeDeleteArray(szText);
+}
 
-void TEventLauncher::Init() {}
+void TEventLauncher::Init()
+{
+}
 
 bool TEventLauncher::Load(cParser *parser)
 { // wczytanie wyzwalacza zdarzeñ

FadeSound.cpp

@@ -27,9 +27,14 @@ TFadeSound::TFadeSound()
     fTime = 0;
 }
 
-TFadeSound::~TFadeSound() { Free(); }
+TFadeSound::~TFadeSound()
+{
+    Free();
+}
 
-void TFadeSound::Free() {}
+void TFadeSound::Free()
+{
+}
 
 void TFadeSound::Init(char *Name, float fNewFade)
 {
@@ -47,7 +52,10 @@ void TFadeSound::TurnOn()
     fTime = fFade;
 }
 
-void TFadeSound::TurnOff() { State = ss_ShuttingDown; }
+void TFadeSound::TurnOff()
+{
+    State = ss_ShuttingDown;
+}
 
 void TFadeSound::Update()
 {

FadeSound.h

@@ -26,7 +26,10 @@ class TFadeSound
     void Init(char *Name, float fNewFade);
     void TurnOn();
     void TurnOff();
-    bool Playing() { return (State == ss_Commencing || State == ss_Starting); };
+    bool Playing()
+    {
+        return (State == ss_Commencing || State == ss_Starting);
+    };
     void Free();
     void Update();
     void Volume(long vol);

Float3d.h

@@ -37,7 +37,10 @@ inline float3 &operator+=(float3 &v1, const float3 &v2)
     v1.z += v2.z;
     return v1;
 };
-inline float3 operator-(const float3 &v) { return float3(-v.x, -v.y, -v.z); };
+inline float3 operator-(const float3 &v)
+{
+    return float3(-v.x, -v.y, -v.z);
+};
 inline float3 operator-(const float3 &v1, const float3 &v2)
 {
     return float3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
@@ -46,8 +49,14 @@ inline float3 operator+(const float3 &v1, const float3 &v2)
 {
     return float3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
 };
-double inline float3::Length() const { return sqrt(x * x + y * y + z * z); };
+double inline float3::Length() const
-inline float3 operator/(const float3 &v, double k) { return float3(v.x / k, v.y / k, v.z / k); };
+{
+    return sqrt(x * x + y * y + z * z);
+};
+inline float3 operator/(const float3 &v, double k)
+{
+    return float3(v.x / k, v.y / k, v.z / k);
+};
 inline float3 SafeNormalize(const float3 &v)
 { // bezpieczna normalizacja (wektor d³ugoœci 1.0)
     double l = v.Length();
@@ -79,8 +88,14 @@ class float4
         z = c;
         w = d;
     };
-    double inline float4::LengthSquared() const { return x * x + y * y + z * z + w * w; };
+    double inline float4::LengthSquared() const
-    double inline float4::Length() const { return sqrt(x * x + y * y + z * z + w * w); };
+    {
+        return x * x + y * y + z * z + w * w;
+    };
+    double inline float4::Length() const
+    {
+        return sqrt(x * x + y * y + z * z + w * w);
+    };
 };
 inline float4 operator*(const float4 &q1, const float4 &q2)
 { // mno¿enie to prawie jak mno¿enie macierzy
@@ -177,15 +192,24 @@ class float4x4
         for (int i = 0; i < 16; ++i)
             e[i] = f[i];
     };
-    float *__fastcall operator()(int i) { return &e[i << 2]; }
+    float *__fastcall operator()(int i)
-    const float *__fastcall readArray(void) { return e; }
+    {
+        return &e[i << 2];
+    }
+    const float *__fastcall readArray(void)
+    {
+        return e;
+    }
     void Identity()
     {
         for (int i = 0; i < 16; ++i)
             e[i] = 0;
         e[0] = e[5] = e[10] = e[15] = 1.0f;
     }
-    const float *operator[](int i) const { return &e[i << 2]; };
+    const float *operator[](int i) const
+    {
+        return &e[i << 2];
+    };
     void InitialRotate()
     { // taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
         float f;
@@ -206,7 +230,10 @@ class float4x4
         return true;
     }
     void Quaternion(float4 *q);
-    inline float3 *TranslationGet() { return (float3 *)(e + 12); }
+    inline float3 *TranslationGet()
+    {
+        return (float3 *)(e + 12);
+    }
 };
 
 inline float3 operator*(const float4x4 &m, const float3 &v)

Gauge.cpp

@@ -46,8 +46,8 @@ void TGauge::Clear()
     fDesiredValue = 0;
 };
 
-void TGauge::Init(TSubModel *NewSubModel, TGaugeType eNewType, double fNewScale,
+void TGauge::Init(TSubModel *NewSubModel, TGaugeType eNewType, double fNewScale, double fNewOffset,
-                             double fNewOffset, double fNewFriction, double fNewValue)
+                  double fNewFriction, double fNewValue)
 { // ustawienie parametrów animacji submodelu
     if (NewSubModel)
     { // warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³

Gauge.h

@@ -50,14 +50,16 @@ class TGauge // zmienne "gg"
     void Clear();
     void Init(TSubModel *NewSubModel, TGaugeType eNewTyp, double fNewScale = 1,
               double fNewOffset = 0, double fNewFriction = 0, double fNewValue = 0);
-    bool Load(TQueryParserComp *Parser, TModel3d *md1, TModel3d *md2 = NULL,
+    bool Load(TQueryParserComp *Parser, TModel3d *md1, TModel3d *md2 = NULL, double mul = 1.0);
-                         double mul = 1.0);
     void PermIncValue(double fNewDesired);
     void IncValue(double fNewDesired);
     void DecValue(double fNewDesired);
     void UpdateValue(double fNewDesired);
     void PutValue(double fNewDesired);
-    float GetValue() { return fValue; };
+    float GetValue()
+    {
+        return fValue;
+    };
     void Update();
     void Render();
     void AssignFloat(float *fValue);

Geom.cpp

@@ -19,11 +19,17 @@ http://mozilla.org/MPL/2.0/.
 #include "Globals.h"
 #include "Geom.h"
 
-__fastcall TGeometry::TGeometry() {}
+__fastcall TGeometry::TGeometry()
+{
+}
 
-__fastcall TGeometry::~TGeometry() {}
+__fastcall TGeometry::~TGeometry()
+{
+}
 
-bool TGeometry::Init() {}
+bool TGeometry::Init()
+{
+}
 
 vector3 TGeometry::Load(TQueryParserComp *Parser)
 {
@@ -113,7 +119,9 @@ vector3 TGeometry::Load(TQueryParserComp *Parser)
     tmp->fSquareRadius += r;
 }
 
-bool TGeometry::Render() {}
+bool TGeometry::Render()
+{
+}
 //---------------------------------------------------------------------------
 
 #pragma package(smart_init)

Globals.cpp

@@ -49,9 +49,9 @@ double Global::fLuminance = 1.0; // jasno
 int Global::iReCompile = 0; // zwiêkszany, gdy trzeba odœwie¿yæ siatki
 HWND Global::hWnd = NULL; // uchwyt okna
 int Global::iCameraLast = -1;
-AnsiString Global::asRelease = "15.3.1167.470";
+AnsiString Global::asRelease = "15.3.1168.471";
 AnsiString Global::asVersion =
-    "Compilation 2015-04-14, release " + Global::asRelease + "."; // tutaj, bo wysy³any
+    "Compilation 2015-04-17, release " + Global::asRelease + "."; // tutaj, bo wysy³any
 int Global::iViewMode = 0; // co aktualnie widaæ: 0-kabina, 1-latanie, 2-sprzêgi, 3-dokumenty
 int Global::iTextMode = 0; // tryb pracy wyœwietlacza tekstowego
 int Global::iScreenMode[12] = {0, 0, 0, 0, 0, 0,
@@ -465,6 +465,10 @@ void Global::ConfigParse(TQueryParserComp *qp, cParser *cp)
             asLang = GetNextSymbol(); // domyœlny jêzyk - http://tools.ietf.org/html/bcp47
         else if (str == AnsiString("opengl")) // deklarowana wersja OpenGL, ¿eby powstrzymaæ b³êdy
             fOpenGL = GetNextSymbol().ToDouble(); // wymuszenie wersji OpenGL
+        else if (str == AnsiString("pyscreenrendererpriority")) // priority of python screen
+                                                                // renderer
+            TPythonInterpreter::getInstance()->setScreenRendererPriority(
+                GetNextSymbol().LowerCase().c_str());
     } while (str != "endconfig"); //(!Parser->EndOfFile)
     // na koniec trochê zale¿noœci
     if (!bLoadTraction) // wczytywanie drutów i s³upów

Globals.h

@@ -14,6 +14,7 @@ http://mozilla.org/MPL/2.0/.
 #include "system.hpp"
 #include "opengl/glew.h"
 #include "dumb3d.h"
+#include "PyInt.h"
 //#include "Classes.h"
 
 using namespace Math3D;
@@ -206,7 +207,10 @@ class Global
     static AnsiString asHumanCtrlVehicle;
     static void LoadIniFile(AnsiString asFileName);
     static void InitKeys(AnsiString asFileName);
-    inline static vector3 GetCameraPosition() { return pCameraPosition; };
+    inline static vector3 GetCameraPosition()
+    {
+        return pCameraPosition;
+    };
     static void SetCameraPosition(vector3 pNewCameraPosition);
     static void SetCameraRotation(double Yaw);
     static int iWriteLogEnabled; // maska bitowa: 1-zapis do pliku, 2-okienko

Ground.cpp

@@ -1626,8 +1626,7 @@ TGroundNode *__fastcall TGround::AddGroundNode(cParser *parser)
         *parser >> tmp->hvTraction->NominalVoltage >> tmp->hvTraction->MaxCurrent >>
             tmp->hvTraction->fResistivity;
         if (tmp->hvTraction->fResistivity == 0.01) // tyle jest w sceneriach [om/km]
-            tmp->hvTraction->fResistivity =
+            tmp->hvTraction->fResistivity = 0.075; // taka sensowniejsza wartoϾ za
-                0.075; // taka sensowniejsza wartoϾ za
         // http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf
         tmp->hvTraction->fResistivity *= 0.001; // teraz [om/m]
         parser->getTokens();
@@ -3210,7 +3209,6 @@ void TGround::InitTracks()
                 if (Track->asEventall2Name.IsEmpty())
                     if (FindEvent(Current->asName + ":eventall2"))
                         Track->asEventall2Name = Current->asName + ":eventall2";
-
             }
         Track->AssignEvents(
             Track->asEvent0Name.IsEmpty() ? NULL : FindEvent(Track->asEvent0Name),
@@ -4454,7 +4452,8 @@ bool TGround::GetTraction(TDynamicObject *model)
                                                     false) // jeœli drut jest ni¿ej ni¿ 15cm pod
                                             // œlizgiem
                                             { // prze³¹czamy w tryb po³amania, o ile jedzie;
-                                              // (bEnableTraction) aby da³o siê jeŸdziæ na koœlawych
+                                                // (bEnableTraction) aby da³o siê jeŸdziæ na
+                                                // koœlawych
                                                 // sceneriach
                                                 fHorizontal = fabs(DotProduct(vGdzie, vLeft)) -
                                                               p->fWidth; // i do tego jeszcze

Ground.h

@@ -193,8 +193,7 @@ class TSubRect : public Resource, public CMesh
     TSubRect();
     virtual ~TSubRect();
     virtual void Release(); // zwalnianie VBO sektora
-    void NodeAdd(
+    void NodeAdd(TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
-        TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
     void RaNodeAdd(TGroundNode *Node); // dodanie obiektu do listy renderowania
     void Sort(); // optymalizacja obiektów w sektorze (sortowanie wg tekstur)
     TTrack *__fastcall FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
@@ -227,7 +226,10 @@ class TGroundRect : public TSubRect
   private:
     int iLastDisplay; // numer klatki w której był ostatnio wyświetlany
     TSubRect *pSubRects;
-    void Init() { pSubRects = new TSubRect[iNumSubRects * iNumSubRects]; };
+    void Init()
+    {
+        pSubRects = new TSubRect[iNumSubRects * iNumSubRects];
+    };
 
   public:
     static int iFrameNumber; // numer kolejny wyświetlanej klatki
@@ -359,8 +361,14 @@ class TGround
     };
     TSubRect *__fastcall GetSubRect(int iCol, int iRow);
     TSubRect *__fastcall FastGetSubRect(int iCol, int iRow);
-    int GetRowFromZ(double z) { return (z / fSubRectSize + fHalfTotalNumSubRects); };
+    int GetRowFromZ(double z)
-    int GetColFromX(double x) { return (x / fSubRectSize + fHalfTotalNumSubRects); };
+    {
+        return (z / fSubRectSize + fHalfTotalNumSubRects);
+    };
+    int GetColFromX(double x)
+    {
+        return (x / fSubRectSize + fHalfTotalNumSubRects);
+    };
     TEvent *__fastcall FindEvent(const AnsiString &asEventName);
     TEvent *__fastcall FindEventScan(const AnsiString &asEventName);
     void TrackJoin(TGroundNode *Current);

Machajka.cpp

@@ -15,9 +15,14 @@ http://mozilla.org/MPL/2.0/.
 #include "Timer.h"
 #include "Globals.h"
 
-__fastcall TMachajka::TMachajka() : TTrain() { TTrain::TTrain(); }
+__fastcall TMachajka::TMachajka() : TTrain()
+{
+    TTrain::TTrain();
+}
 
-__fastcall TMachajka::~TMachajka() {}
+__fastcall TMachajka::~TMachajka()
+{
+}
 
 bool TMachajka::Init(TDynamicObject *NewDynamicObject)
 {
@@ -63,11 +68,20 @@ void TMachajka::OnKeyPress(int cKey)
     }
 }
 
-bool TMachajka::Update(double dt) { TTrain::Update(dt); }
+bool TMachajka::Update(double dt)
+{
+    TTrain::Update(dt);
+}
 
-bool TMachajka::UpdateMechPosition() { TTrain::UpdateMechPosition(); }
+bool TMachajka::UpdateMechPosition()
+{
+    TTrain::UpdateMechPosition();
+}
 
-bool TMachajka::Render() { TTrain::Render(); }
+bool TMachajka::Render()
+{
+    TTrain::Render();
+}
 //---------------------------------------------------------------------------
 
 #pragma package(smart_init)

MdlMngr.cpp

@@ -57,7 +57,10 @@ __fastcall TModelsManager::~TModelsManager()
     Free();
 };
   */
-void TModelsManager::Free() { SafeDeleteArray(Models); }
+void TModelsManager::Free()
+{
+    SafeDeleteArray(Models);
+}
 
 TModel3d *__fastcall TModelsManager::LoadModel(char *Name, bool dynamic)
 { // wczytanie modelu do tablicy

MemCell.cpp

@@ -41,12 +41,16 @@ TMemCell::TMemCell(vector3 *p)
     OnSent = NULL;
 }
 
-TMemCell::~TMemCell() { SafeDeleteArray(szText); }
+TMemCell::~TMemCell()
+{
+    SafeDeleteArray(szText);
+}
 
-void TMemCell::Init() {}
+void TMemCell::Init()
+{
+}
 
-void TMemCell::UpdateValues(char *szNewText, double fNewValue1, double fNewValue2,
+void TMemCell::UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask)
-                                       int CheckMask)
 {
     if (CheckMask & update_memadd)
     { // dodawanie wartoœci
@@ -140,8 +144,7 @@ void TMemCell::PutCommand(TController *Mech, vector3 *Loc)
         Mech->PutCommand(szText, fValue1, fValue2, Loc);
 }
 
-bool TMemCell::Compare(char *szTestText, double fTestValue1, double fTestValue2,
+bool TMemCell::Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask)
-                                  int CheckMask)
 { // porównanie zawartoœci komórki pamiêci z podanymi wartoœciami
     if (TestFlag(CheckMask, conditional_memstring))
     { // porównaæ teksty
@@ -161,7 +164,10 @@ bool TMemCell::Compare(char *szTestText, double fTestValue1, double fTestValue2,
             (!TestFlag(CheckMask, conditional_memval2) || (fValue2 == fTestValue2)));
 };
 
-bool TMemCell::Render() { return true; }
+bool TMemCell::Render()
+{
+    return true;
+}
 
 bool TMemCell::IsVelocity()
 { // sprawdzenie, czy event odczytu tej komórki ma byæ do skanowania, czy do kolejkowania

MemCell.h

@@ -30,19 +30,35 @@ class TMemCell
     TMemCell(vector3 *p);
     ~TMemCell();
     void Init();
-    void UpdateValues(char *szNewText, double fNewValue1, double fNewValue2,
+    void UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask);
-                                 int CheckMask);
     bool Load(cParser *parser);
     void PutCommand(TController *Mech, vector3 *Loc);
-    bool Compare(char *szTestText, double fTestValue1, double fTestValue2,
+    bool Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask);
-                            int CheckMask);
     bool Render();
-    inline char *__fastcall Text() { return szText; };
+    inline char *__fastcall Text()
-    inline double Value1() { return fValue1; };
+    {
-    inline double Value2() { return fValue2; };
+        return szText;
-    inline vector3 Position() { return vPosition; };
+    };
-    inline TCommandType Command() { return eCommand; };
+    inline double Value1()
-    inline bool StopCommand() { return bCommand; };
+    {
+        return fValue1;
+    };
+    inline double Value2()
+    {
+        return fValue2;
+    };
+    inline vector3 Position()
+    {
+        return vPosition;
+    };
+    inline TCommandType Command()
+    {
+        return eCommand;
+    };
+    inline bool StopCommand()
+    {
+        return bCommand;
+    };
     void StopCommandSent();
     TCommandType CommandCheck();
     bool IsVelocity();

Model3d.cpp

@@ -178,8 +178,7 @@ void TSubModel::NameSet(const char *n)
 
 // int TSubModel::SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX
 // *Vertices)
-int TSubModel::SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt,
+int TSubModel::SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt, float8 *Vertices)
-                                         float8 *Vertices)
 { // szukanie punktu stycznego do (pt), zwraca numer wierzcho³ka, a nie trójk¹ta
     int iNumFaces = iNumVerts / 3; // bo maska powierzchni jest jedna na trójk¹t
     // GLVERTEX *p; //roboczy wskaŸnik
@@ -916,7 +915,10 @@ void TSubModel::SetRotateIK1(float3 vNewAngles)
 
 struct ToLower
 {
-    char operator()(char input) { return tolower(input); }
+    char operator()(char input)
+    {
+        return tolower(input);
+    }
 };
 
 TSubModel *__fastcall TSubModel::GetFromName(AnsiString search, bool i)
@@ -1523,8 +1525,8 @@ void TSubModel::InfoSet(TSubModelInfo *info)
     pTexture = pName = NULL;
 };
 
-void TSubModel::BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
+void TSubModel::BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t, TStringPack *n,
-                                   TStringPack *n, bool dynamic)
+                        bool dynamic)
 { // ustawienie wskaŸników w submodelu
     iVisible = 1; // tymczasowo u¿ywane
     Child = ((int)Child > 0) ? s + (int)Child : NULL; // zerowy nie mo¿e byæ potomnym
@@ -2019,7 +2021,10 @@ void TModel3d::SaveToBinFile(char *FileName)
     delete[] info;
 };
 
-void TModel3d::BreakHierarhy() { Error("Not implemented yet :("); };
+void TModel3d::BreakHierarhy()
+{
+    Error("Not implemented yet :(");
+};
 
 /*
 void TModel3d::Render(vector3 pPosition,double fAngle,GLuint ReplacableSkinId,int iAlpha)
@@ -2122,8 +2127,7 @@ void TModel3d::RaRender(double fSquareDistance, GLuint *ReplacableSkinId, int iA
     }
 };
 
-void TModel3d::RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId,
+void TModel3d::RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId, int iAlpha)
-                                        int iAlpha)
 { // renderowanie specjalne, np. kabiny
     if (iAlpha & iFlags & 0x2F2F002F) // czy w ogóle jest co robiæ w tym cyklu?
     {
@@ -2159,8 +2163,7 @@ iAlpha)
 // 2011-03-16 cztery nowe funkcje renderowania z mo¿liwoœci¹ pochylania obiektów
 //-----------------------------------------------------------------------------
 
-void TModel3d::Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
+void TModel3d::Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId, int iAlpha)
-                                 int iAlpha)
 { // nieprzezroczyste, Display List
     glPushMatrix();
     glTranslated(vPosition->x, vPosition->y, vPosition->z);
@@ -2194,8 +2197,7 @@ void TModel3d::RenderAlpha(vector3 *vPosition, vector3 *vAngle, GLuint *Replacab
     Root->RenderAlphaDL();
     glPopMatrix();
 };
-void TModel3d::RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
+void TModel3d::RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId, int iAlpha)
-                                   int iAlpha)
 { // nieprzezroczyste, VBO
     glPushMatrix();
     glTranslated(vPosition->x, vPosition->y, vPosition->z);
@@ -2215,8 +2217,8 @@ void TModel3d::RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableS
     }
     glPopMatrix();
 };
-void TModel3d::RaRenderAlpha(vector3 *vPosition, vector3 *vAngle,
+void TModel3d::RaRenderAlpha(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
-                                        GLuint *ReplacableSkinId, int iAlpha)
+                             int iAlpha)
 { // przezroczyste, VBO
     glPushMatrix();
     glTranslated(vPosition->x, vPosition->y, vPosition->z);

Model3d.h

@@ -36,21 +36,33 @@ class TStringPack
     //+8 - tabela indeksów
   public:
     char *String(int n);
-    char *StringAt(int n) { return data + 9 + n; };
+    char *StringAt(int n)
+    {
+        return data + 9 + n;
+    };
     TStringPack()
     {
         data = NULL;
         index = NULL;
     };
-    void Init(char *d) { data = d; };
+    void Init(char *d)
-    void InitIndex(int *i) { index = i; };
+    {
+        data = d;
+    };
+    void InitIndex(int *i)
+    {
+        index = i;
+    };
 };
 
 class TMaterialColor
 {
   public:
     TMaterialColor(){};
-    TMaterialColor(char V) { r = g = b = V; };
+    TMaterialColor(char V)
+    {
+        r = g = b = V;
+    };
     // TMaterialColor(double R, double G, double B)
     TMaterialColor(char R, char G, char B)
     {
@@ -250,8 +262,14 @@ class TSubModel
     int Load(cParser &Parser, TModel3d *Model, int Pos, bool dynamic);
     void ChildAdd(TSubModel *SubModel);
     void NextAdd(TSubModel *SubModel);
-    TSubModel *__fastcall NextGet() { return Next; };
+    TSubModel *__fastcall NextGet()
-    TSubModel *__fastcall ChildGet() { return Child; };
+    {
+        return Next;
+    };
+    TSubModel *__fastcall ChildGet()
+    {
+        return Child;
+    };
     int TriangleAdd(TModel3d *m, int tex, int tri);
     float8 *__fastcall TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
     // float8* TrianglePtr(const char *tex,int tri);
@@ -269,9 +287,15 @@ class TSubModel
     void RenderVBO();
     void RenderAlphaVBO();
     // inline matrix4x4* GetMatrix() {return dMatrix;};
-    inline float4x4 *__fastcall GetMatrix() { return fMatrix; };
+    inline float4x4 *__fastcall GetMatrix()
+    {
+        return fMatrix;
+    };
     // matrix4x4* GetTransform() {return Matrix;};
-    inline void Hide() { iVisible = 0; };
+    inline void Hide()
+    {
+        iVisible = 0;
+    };
     void RaArrayFill(CVertNormTex *Vert);
     // void Render();
     int FlagsCheck();
@@ -284,8 +308,8 @@ class TSubModel
     void DisplayLists();
     void Info();
     void InfoSet(TSubModelInfo *info);
-    void BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
+    void BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t, TStringPack *n = NULL,
-                            TStringPack *n = NULL, bool dynamic = false);
+                 bool dynamic = false);
     void ReplacableSet(GLuint *r, int a)
     {
         ReplacableSkinId = r;
@@ -294,8 +318,14 @@ class TSubModel
     void TextureNameSet(const char *n);
     void NameSet(const char *n);
     // Ra: funkcje do budowania terenu z E3D
-    int Flags() { return iFlags; };
+    int Flags()
-    void UnFlagNext() { iFlags &= 0x00FFFFFF; };
+    {
+        return iFlags;
+    };
+    void UnFlagNext()
+    {
+        iFlags &= 0x00FFFFFF;
+    };
     void ColorsSet(int *a, int *d, int *s);
     inline float3 Translation1Get()
     {
@@ -305,6 +335,10 @@ class TSubModel
     {
         return *(fMatrix->TranslationGet()) + Child->Translation1Get();
     }
+    int GetTextureId()
+    {
+        return TextureID;
+    }
     void ParentMatrix(float4x4 *m);
     float MaxY(const float4x4 &m);
     void AdjustDist();
@@ -356,7 +390,10 @@ class TModel3d : public CMesh
     int iSubModelsCount; // Ra: używane do tworzenia binarnych
     AnsiString asBinary; // nazwa pod którą zapisać model binarny
   public:
-    inline TSubModel *__fastcall GetSMRoot() { return (Root); };
+    inline TSubModel *__fastcall GetSMRoot()
+    {
+        return (Root);
+    };
     // double Radius; //Ra: nie używane
     TModel3d();
     TModel3d(char *FileName);
@@ -371,36 +408,40 @@ class TModel3d : public CMesh
     void SaveToBinFile(char *FileName);
     void BreakHierarhy();
     // renderowanie specjalne
-    void Render(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
+    void Render(double fSquareDistance, GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
-                           int iAlpha = 0x30300030);
     void RenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
                      int iAlpha = 0x30300030);
-    void RaRender(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
+    void RaRender(double fSquareDistance, GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
-                             int iAlpha = 0x30300030);
     void RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
                        int iAlpha = 0x30300030);
     // jeden kąt obrotu
     void Render(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
                 int iAlpha = 0x30300030);
-    void RenderAlpha(vector3 pPosition, double fAngle = 0,
+    void RenderAlpha(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
-                                GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
+                     int iAlpha = 0x30300030);
     void RaRender(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
                   int iAlpha = 0x30300030);
-    void RaRenderAlpha(vector3 pPosition, double fAngle = 0,
+    void RaRenderAlpha(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
-                                  GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
+                       int iAlpha = 0x30300030);
     // trzy kąty obrotu
     void Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
                 int iAlpha = 0x30300030);
-    void RenderAlpha(vector3 *vPosition, vector3 *vAngle,
+    void RenderAlpha(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
-                                GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
+                     int iAlpha = 0x30300030);
     void RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
                   int iAlpha = 0x30300030);
-    void RaRenderAlpha(vector3 *vPosition, vector3 *vAngle,
+    void RaRenderAlpha(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
-                                  GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
+                       int iAlpha = 0x30300030);
     // inline int GetSubModelsCount() { return (SubModelsCount); };
-    int Flags() { return iFlags; };
+    int Flags()
+    {
+        return iFlags;
+    };
     void Init();
-    char *__fastcall NameGet() { return Root ? Root->pName : NULL; };
+    char *__fastcall NameGet()
+    {
+        return Root ? Root->pName : NULL;
+    };
     int TerrainCount();
     TSubModel *__fastcall TerrainSquare(int n);
     void TerrainRenderVBO(int n);

Mover.cpp

@@ -16,9 +16,8 @@ http://mozilla.org/MPL/2.0/.
 
 const dEpsilon = 0.01; // 1cm (zale¿y od typu sprzêgu...)
 
-TMoverParameters::TMoverParameters(double VelInitial, AnsiString TypeNameInit,
+TMoverParameters::TMoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
-                                              AnsiString NameInit, int LoadInitial,
+                                   int LoadInitial, AnsiString LoadTypeInitial, int Cab)
-                                              AnsiString LoadTypeInitial, int Cab)
     : T_MoverParameters(VelInitial, TypeNameInit, NameInit, LoadInitial, LoadTypeInitial, Cab)
 { // g³ówny konstruktor
     DimHalf.x = 0.5 * Dim.W; // po³owa szerokoœci, OX jest w bok?
@@ -37,8 +36,8 @@ double TMoverParameters::Distance(const TLocation &Loc1, const TLocation &Loc2,
     return hypot(Loc2.X - Loc1.X, Loc1.Y - Loc2.Y) - 0.5 * (Dim2.L + Dim1.L);
 };
 
-double TMoverParameters::Distance(const vector3 &s1, const vector3 &s2,
+double TMoverParameters::Distance(const vector3 &s1, const vector3 &s2, const vector3 &d1,
-                                             const vector3 &d1, const vector3 &d2){
+                                  const vector3 &d2){
     // obliczenie odleg³oœci prostopad³oœcianów o œrodkach (s1) i (s2) i wymiarach (d1) i (d2)
     // return 0.0; //bêdzie zg³aszaæ warning - funkcja do usuniêcia, chyba ¿e siê przyda...
 };
@@ -50,9 +49,8 @@ double TMoverParameters::CouplerDist(Byte Coupler)
                         Couplers[Coupler].Connected->Dim); // odleg³oœæ pomiêdzy sprzêgami (kula!)
 };
 
-bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr,
+bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo,
-                                         TMoverParameters *ConnectTo, Byte CouplingType,
+                              Byte CouplingType, bool Forced)
-                                         bool Forced)
 { //³¹czenie do swojego sprzêgu (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr)
     // Ra: zwykle wykonywane dwukrotnie, dla ka¿dego pojazdu oddzielnie
     // Ra: trzeba by odró¿niæ wymóg dociœniêcia od uszkodzenia sprzêgu przy podczepianiu AI do
@@ -94,9 +92,8 @@ bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr,
     // sprzêgu, brak haka
 };
 
-bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr,
+bool TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo,
-                                         T_MoverParameters *ConnectTo, Byte CouplingType,
+                              Byte CouplingType, bool Forced)
-                                         bool Forced)
 { //³¹czenie do (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr)
     return Attach(ConnectNo, ConnectToNr, (TMoverParameters *)ConnectTo, CouplingType, Forced);
 };
@@ -234,10 +231,13 @@ bool TMoverParameters::BrakeLevelAdd(double b)
 
 bool TMoverParameters::IncBrakeLevel()
 { // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê BrakeCtrlPosNo
-  return BrakeLevelAdd(1.0); };
+    return BrakeLevelAdd(1.0);
+};
 
 bool TMoverParameters::DecBrakeLevel()
-{ return BrakeLevelAdd(-1.0); }; // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê -1
+{ // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê -1
+    return BrakeLevelAdd(-1.0);
+};
 
 bool TMoverParameters::ChangeCab(int direction)
 { // zmiana kabiny i resetowanie ustawien
@@ -475,8 +475,7 @@ ZN //masa
 */
 
 double TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
-                                                    TTrackParam &Track,
+                                         TTrackParam &Track, TTractionParam &ElectricTraction,
-                                                    TTractionParam &ElectricTraction,
                                          const TLocation &NewLoc, TRotation &NewRot)
 { // trzeba po ma³u przenosiæ tu tê funkcjê
     double d;

Mover.h

@@ -50,10 +50,10 @@ class TMoverParameters : public T_MoverParameters
                     const TDimension &Dim2);
     double Distance(const vector3 &Loc1, const vector3 &Loc2, const vector3 &Dim1,
                     const vector3 &Dim2);
-    bool Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo,
+    bool Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo, Byte CouplingType,
-                           Byte CouplingType, bool Forced = false);
+                bool Forced = false);
-    bool Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo,
+    bool Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo, Byte CouplingType,
-                           Byte CouplingType, bool Forced = false);
+                bool Forced = false);
     int DettachStatus(Byte ConnectNo);
     bool Dettach(Byte ConnectNo);
     void SetCoupleDist();
@@ -65,9 +65,9 @@ class TMoverParameters : public T_MoverParameters
     bool ChangeCab(int direction);
     bool CurrentSwitch(int direction);
     void UpdateBatteryVoltage(double dt);
-    double ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
+    double ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track,
-                                      TTrackParam &Track, TTractionParam &ElectricTraction,
+                           TTractionParam &ElectricTraction, const TLocation &NewLoc,
-                                      const TLocation &NewLoc, TRotation &NewRot);
+                           TRotation &NewRot);
     double FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track,
                                const TLocation &NewLoc, TRotation &NewRot);
     double ShowEngineRotation(int VehN);

Names.h

@@ -26,8 +26,14 @@ class ItemRecord
     // typedef
     void ListGet(ItemRecord *r, int *&n);
     void TreeAdd(ItemRecord *r, int c);
-    template <typename TOut> inline TOut *DataGet() { return (TOut *)pData; };
+    template <typename TOut> inline TOut *DataGet()
-    template <typename TOut> inline void DataSet(TOut *x) { pData = (void *)x; };
+    {
+        return (TOut *)pData;
+    };
+    template <typename TOut> inline void DataSet(TOut *x)
+    {
+        pData = (void *)x;
+    };
     void *__fastcall TreeFind(const char *n);
     ItemRecord *__fastcall TreeFindRecord(const char *n);
 };
@@ -46,8 +52,7 @@ class TNames
     int Add(int t, const char *n); // dodanie obiektu typu (t)
     int Add(int t, const char *n, void *d); // dodanie obiektu z wskaŸnikiem
     int Add(int t, const char *n, int d); // dodanie obiektu z numerem
-    bool Update(int t, const char *n,
+    bool Update(int t, const char *n, void *d); // dodanie jeœli nie ma, wymiana (d), gdy jest
-                           void *d); // dodanie jeœli nie ma, wymiana (d), gdy jest
     void TreeSet();
     ItemRecord *__fastcall TreeSet(int *n, int d, int u);
     void Sort(int t); // przebudowa drzewa typu (t)

PyInt.cpp

@@ -0,0 +1,601 @@
+#include "PyInt.h"
+#include "Train.h"
+#include "Logs.h"
+#include <process.h>
+#include <windows.h>
+#include <stdlib.h>
+
+TPythonInterpreter *TPythonInterpreter::_instance = NULL;
+
+//#define _PY_INT_MORE_LOG
+
+TPythonInterpreter::TPythonInterpreter()
+{
+    WriteLog("Loading Python ...");
+    Py_SetPythonHome("python");
+    Py_Initialize();
+    _main = PyImport_ImportModule("__main__");
+    if (_main == NULL)
+    {
+        WriteLog("Cannot import Python module __main__");
+    }
+    _screenRendererPriority = THREAD_PRIORITY_NORMAL; // domyslny priorytet normalny
+    PyObject *cStringModule = PyImport_ImportModule("cStringIO");
+    _stdErr = NULL;
+    if (cStringModule == NULL)
+        return;
+    PyObject *cStringClassName = PyObject_GetAttrString(cStringModule, "StringIO");
+    if (cStringClassName == NULL)
+        return;
+    PyObject *cString = PyObject_CallObject(cStringClassName, NULL);
+    if (cString == NULL)
+        return;
+    if (PySys_SetObject("stderr", cString) != 0)
+        return;
+    _stdErr = cString;
+}
+
+TPythonInterpreter *TPythonInterpreter::getInstance()
+{
+    if (!_instance)
+    {
+        _instance = new TPythonInterpreter();
+    }
+    return _instance;
+}
+
+bool TPythonInterpreter::loadClassFile(const char *lookupPath, const char *className)
+{
+    std::set<const char *, ltstr>::const_iterator it = _classes.find(className);
+    if (it == _classes.end())
+    {
+        FILE *sourceFile = _getFile(lookupPath, className);
+        if (sourceFile != NULL)
+        {
+            fseek(sourceFile, 0, SEEK_END);
+            long fsize = ftell(sourceFile);
+            char *buffer = (char *)calloc(fsize + 1, sizeof(char));
+            fseek(sourceFile, 0, SEEK_SET);
+            long freaded = fread(buffer, sizeof(char), fsize, sourceFile);
+            buffer[freaded] = 0; // z jakiegos powodu czytamy troche mniej i trzczeba dodac konczace
+// zero do bufora (mimo ze calloc teoretycznie powiniene zwrocic
+// wyzerowana pamiec)
+#ifdef _PY_INT_MORE_LOG
+            char buf[255];
+            sprintf(buf, "readed %d / %d characters for %s", freaded, fsize, className);
+            WriteLog(buf);
+#endif // _PY_INT_MORE_LOG
+            fclose(sourceFile);
+            if (PyRun_SimpleString(buffer) != 0)
+            {
+                handleError();
+                return false;
+            }
+            char *classNameToRemember = (char *)calloc(strlen(className) + 1, sizeof(char));
+            strcpy(classNameToRemember, className);
+            _classes.insert(classNameToRemember);
+            free(buffer);
+            return true;
+        }
+        return false;
+    }
+    return true;
+}
+
+PyObject *TPythonInterpreter::newClass(const char *className)
+{
+    return newClass(className, NULL);
+}
+
+FILE *TPythonInterpreter::_getFile(const char *lookupPath, const char *className)
+{
+    char *sourceFilePath;
+    if (lookupPath != NULL)
+    {
+        sourceFilePath = (char *)calloc(strlen(lookupPath) + strlen(className) + 4, sizeof(char));
+        strcat(sourceFilePath, lookupPath);
+        strcat(sourceFilePath, className);
+        strcat(sourceFilePath, ".py");
+
+        FILE *file = fopen(sourceFilePath, "r");
+#ifdef _PY_INT_MORE_LOG
+        WriteLog(sourceFilePath);
+#endif // _PY_INT_MORE_LOG
+        free(sourceFilePath);
+        if (file != NULL)
+        {
+            return file;
+        }
+    }
+    char *basePath = "python\\local\\";
+    sourceFilePath = (char *)calloc(strlen(basePath) + strlen(className) + 4, sizeof(char));
+    strcat(sourceFilePath, basePath);
+    strcat(sourceFilePath, className);
+    strcat(sourceFilePath, ".py");
+
+    FILE *file = fopen(sourceFilePath, "r");
+#ifdef _PY_INT_MORE_LOG
+    WriteLog(sourceFilePath);
+#endif // _PY_INT_MORE_LOG
+    free(sourceFilePath);
+    if (file != NULL)
+    {
+        return file;
+    }
+    return NULL;
+}
+
+void TPythonInterpreter::handleError()
+{
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("Python Error occured");
+#endif // _PY_INT_MORE_LOG
+    if (_stdErr != NULL)
+    { // std err pythona jest buforowane
+        PyErr_Print();
+        PyObject *bufferContent = PyObject_CallMethod(_stdErr, "getvalue", NULL);
+        PyObject_CallMethod(_stdErr, "truncate", "i", 0); // czyscimy bufor na kolejne bledy
+        WriteLog(PyString_AsString(bufferContent));
+    }
+    else
+    { // nie dziala buffor pythona
+        if (PyErr_Occurred() != NULL)
+        {
+            PyObject *ptype, *pvalue, *ptraceback;
+            PyErr_Fetch(&ptype, &pvalue, &ptraceback);
+            if (ptype == NULL)
+            {
+                WriteLog("Don't konw how to handle NULL exception");
+            }
+            PyErr_NormalizeException(&ptype, &pvalue, &ptraceback);
+            if (ptype == NULL)
+            {
+                WriteLog("Don't konw how to handle NULL exception");
+            }
+            PyObject *pStrType = PyObject_Str(ptype);
+            if (pStrType != NULL)
+            {
+                WriteLog(PyString_AsString(pStrType));
+            }
+            WriteLog(PyString_AsString(pvalue));
+            PyObject *pStrTraceback = PyObject_Str(ptraceback);
+            if (pStrTraceback != NULL)
+            {
+                WriteLog(PyString_AsString(pStrTraceback));
+            }
+            else
+            {
+                WriteLog("Python Traceback cannot be shown");
+            }
+        }
+        else
+        {
+#ifdef _PY_INT_MORE_LOG
+            WriteLog("Called python error handler when no error occured!");
+#endif // _PY_INT_MORE_LOG
+        }
+    }
+}
+PyObject *TPythonInterpreter::newClass(const char *className, PyObject *argsTuple)
+{
+    if (_main == NULL)
+    {
+        WriteLog("main turned into null");
+        return NULL;
+    }
+    PyObject *classNameObj = PyObject_GetAttrString(_main, className);
+    if (classNameObj == NULL)
+    {
+#ifdef _PY_INT_MORE_LOG
+        char buf[255];
+        sprintf(buf, "Python class %s not defined!", className);
+        WriteLog(buf);
+#endif // _PY_INT_MORE_LOG
+        return NULL;
+    }
+    PyObject *object = PyObject_CallObject(classNameObj, argsTuple);
+
+    if (PyErr_Occurred() != NULL)
+    {
+        handleError();
+        return NULL;
+    }
+    return object;
+}
+
+void TPythonInterpreter::setScreenRendererPriority(const char *priority)
+{
+    if (strncmp(priority, "normal", 6) == 0)
+    {
+        _screenRendererPriority = THREAD_PRIORITY_NORMAL;
+#ifdef _PY_INT_MORE_LOG
+        WriteLog("Python screen renderer priority: Normal");
+#endif // _PY_INT_MORE_LOG
+    }
+    else if (strncmp(priority, "lower", 5) == 0)
+    {
+        _screenRendererPriority = THREAD_PRIORITY_BELOW_NORMAL;
+#ifdef _PY_INT_MORE_LOG
+        WriteLog("Python screen renderer priority: Lower");
+#endif // _PY_INT_MORE_LOG
+    }
+    else if (strncmp(priority, "lowest", 6) == 0)
+    {
+        _screenRendererPriority = THREAD_PRIORITY_LOWEST;
+#ifdef _PY_INT_MORE_LOG
+        WriteLog("Python screen renderer priority: Lowest");
+#endif // _PY_INT_MORE_LOG
+    }
+    else if (strncmp(priority, "idle", 4) == 0)
+    {
+        _screenRendererPriority = THREAD_PRIORITY_IDLE;
+#ifdef _PY_INT_MORE_LOG
+        WriteLog("Python screen renderer priority: Idle");
+#endif // _PY_INT_MORE_LOG
+    }
+}
+
+TPythonScreenRenderer::TPythonScreenRenderer(int textureId, PyObject *renderer)
+{
+    _textureId = textureId;
+    _pyRenderer = renderer;
+}
+
+void TPythonScreenRenderer::updateTexture()
+{
+    int width, height;
+    if (_pyWidth == NULL || _pyHeight == NULL)
+    {
+        WriteLog("Unknown python texture size!");
+        return;
+    }
+    width = PyInt_AsLong(_pyWidth);
+    height = PyInt_AsLong(_pyHeight);
+    if (_pyTexture != NULL)
+    {
+        char *textureData = PyString_AsString(_pyTexture);
+        if (textureData != NULL)
+        {
+#ifdef _PY_INT_MORE_LOG
+            char buff[255];
+            sprintf(buff, "Sending texture id: %d w: %d h: %d", _textureId, width, height);
+            WriteLog(buff);
+#endif // _PY_INT_MORE_LOG
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+            glBindTexture(GL_TEXTURE_2D, _textureId);
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE,
+                         textureData);
+#ifdef _PY_INT_MORE_LOG
+            GLenum status = glGetError();
+            switch (status)
+            {
+            case GL_INVALID_ENUM:
+                WriteLog("An unacceptable value is specified for an enumerated argument. The "
+                         "offending function is ignored, having no side effect other than to set "
+                         "the error flag.");
+                break;
+            case GL_INVALID_VALUE:
+                WriteLog("A numeric argument is out of range. The offending function is ignored, "
+                         "having no side effect other than to set the error flag.");
+                break;
+            case GL_INVALID_OPERATION:
+                WriteLog("The specified operation is not allowed in the current state. The "
+                         "offending function is ignored, having no side effect other than to set "
+                         "the error flag.");
+                break;
+            case GL_NO_ERROR:
+                WriteLog("No error has been recorded. The value of this symbolic constant is "
+                         "guaranteed to be zero.");
+                break;
+            case GL_STACK_OVERFLOW:
+                WriteLog("This function would cause a stack overflow. The offending function is "
+                         "ignored, having no side effect other than to set the error flag.");
+                break;
+            case GL_STACK_UNDERFLOW:
+                WriteLog("This function would cause a stack underflow. The offending function is "
+                         "ignored, having no side effect other than to set the error flag.");
+                break;
+            case GL_OUT_OF_MEMORY:
+                WriteLog("There is not enough memory left to execute the function. The state of "
+                         "OpenGL is undefined, except for the state of the error flags, after this "
+                         "error is recorded.");
+                break;
+            };
+#endif // _PY_INT_MORE_LOG
+        }
+        else
+        {
+            WriteLog("RAW python texture data is NULL!");
+        }
+    }
+    else
+    {
+        WriteLog("Python texture object is NULL!");
+    }
+}
+
+void TPythonScreenRenderer::render(PyObject *trainState)
+{
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("Python rendering texture ...");
+#endif // _PY_INT_MORE_LOG
+    _pyTexture = PyObject_CallMethod(_pyRenderer, "render", "O", trainState);
+
+    if (_pyTexture == NULL)
+    {
+        TPythonInterpreter::getInstance()->handleError();
+    }
+    else
+    {
+        _pyWidth = PyObject_CallMethod(_pyRenderer, "get_width", NULL);
+        if (_pyWidth == NULL)
+        {
+            TPythonInterpreter::getInstance()->handleError();
+        }
+        _pyHeight = PyObject_CallMethod(_pyRenderer, "get_height", NULL);
+        if (_pyHeight == NULL)
+        {
+            TPythonInterpreter::getInstance()->handleError();
+        }
+    }
+}
+
+TPythonScreenRenderer::~TPythonScreenRenderer()
+{
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("PythonScreenRenderer descturctor called");
+#endif // _PY_INT_MORE_LOG
+    if (_pyRenderer != NULL)
+    {
+        Py_CLEAR(_pyRenderer);
+    }
+    cleanup();
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("PythonScreenRenderer desctructor finished");
+#endif // _PY_INT_MORE_LOG
+}
+
+void TPythonScreenRenderer::cleanup()
+{
+    if (_pyTexture != NULL)
+    {
+        Py_CLEAR(_pyTexture);
+        _pyTexture = NULL;
+    }
+    if (_pyWidth != NULL)
+    {
+        Py_CLEAR(_pyWidth);
+        _pyWidth = NULL;
+    }
+    if (_pyHeight != NULL)
+    {
+        Py_CLEAR(_pyHeight);
+        _pyHeight = NULL;
+    }
+}
+
+void TPythonScreens::reset(void *train)
+{
+    _terminationFlag = true;
+    if (_thread != NULL)
+    {
+        WriteLog("Awaiting python thread to end");
+        WaitForSingleObject(_thread, INFINITE);
+        _thread = NULL;
+    }
+    _terminationFlag = false;
+    _cleanupReadyFlag = false;
+    _renderReadyFlag = false;
+    for (std::vector<TPythonScreenRenderer *>::iterator i = _screens.begin(); i != _screens.end();
+         ++i)
+    {
+        delete *i;
+    }
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("Clearing renderer vector");
+#endif // _PY_INT_MORE_LOG
+    _screens.clear();
+    _train = train;
+}
+
+void TPythonScreens::init(TQueryParserComp *parser, TModel3d *model, AnsiString name, int cab)
+{
+    char buff[255];
+    AnsiString asSubModelName = parser->GetNextSymbol();
+    AnsiString asPyClassName = parser->GetNextSymbol();
+    char *subModelName = (char *)calloc(asSubModelName.Length() + 1, sizeof(char));
+    strcpy(subModelName, asSubModelName.LowerCase().c_str());
+    char *pyClassName = (char *)calloc(asPyClassName.Length() + 1, sizeof(char));
+    strcpy(pyClassName, asPyClassName.LowerCase().c_str());
+    TSubModel *subModel = model->GetFromName(subModelName);
+    if (subModel == NULL)
+    {
+        sprintf(buff, "Python Screen: submodel %s not found - Ignoring screen", subModelName);
+        WriteLog(buff);
+        free(subModelName);
+        free(pyClassName);
+        return; // nie ma takiego sub modelu w danej kabinie pomijamy
+    }
+    int textureId = subModel->GetTextureId();
+    if (textureId <= 0)
+    {
+        sprintf(buff, "Python Screen: invalid texture id %d - Ignoring screen", textureId);
+        WriteLog(buff);
+        free(subModelName);
+        free(pyClassName);
+        return; // sub model nie posiada tekstury lub tekstura wymienna - nie obslugiwana
+    }
+    TPythonInterpreter *python = TPythonInterpreter::getInstance();
+    python->loadClassFile(_lookupPath, pyClassName);
+    PyObject *args = Py_BuildValue("(ssi)", _lookupPath, name.c_str(), cab);
+    if (args == NULL)
+    {
+        WriteLog("Python Screen: cannot create __init__ arguments");
+        free(subModelName);
+        free(pyClassName);
+        return;
+    }
+    PyObject *pyRenderer = python->newClass(pyClassName, args);
+    Py_CLEAR(args);
+    if (pyRenderer == NULL)
+    {
+        sprintf(buff, "Python Screen: null renderer for %s - Ignoring screen", pyClassName);
+        WriteLog(buff);
+        free(subModelName);
+        free(pyClassName);
+        return; // nie mozna utworzyc obiektu Pythonowego
+    }
+    TPythonScreenRenderer *renderer = new TPythonScreenRenderer(textureId, pyRenderer);
+    _screens.push_back(renderer);
+    sprintf(buff, "Created python screen %s on submodel %s (%d)", pyClassName, subModelName,
+            textureId);
+    WriteLog(buff);
+    free(subModelName);
+    free(pyClassName);
+}
+
+void TPythonScreens::update()
+{
+    if (!_renderReadyFlag)
+    {
+        return;
+    }
+    _renderReadyFlag = false;
+    for (std::vector<TPythonScreenRenderer *>::iterator i = _screens.begin(); i != _screens.end();
+         ++i)
+    {
+        (*i)->updateTexture();
+    }
+    _cleanupReadyFlag = true;
+}
+
+void TPythonScreens::setLookupPath(AnsiString path)
+{
+    if (_lookupPath != NULL)
+    {
+        free(_lookupPath);
+    }
+    _lookupPath = (char *)calloc(path.Length() + 1, sizeof(char));
+    strcpy(_lookupPath, path.c_str());
+}
+
+TPythonScreens::TPythonScreens()
+{
+    _lookupPath = NULL;
+    TPythonInterpreter::getInstance()->loadClassFile(NULL, "abstractscreenrenderer");
+    _terminationFlag = false;
+    _renderReadyFlag = false;
+    _cleanupReadyFlag = false;
+    _thread = NULL;
+}
+
+TPythonScreens::~TPythonScreens()
+{
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("Called python sceeens destructor");
+#endif // _PY_INT_MORE_LOG
+    reset(NULL);
+    if (_lookupPath != NULL)
+    {
+#ifdef _PY_INT_MORE_LOG
+        WriteLog("Freeing lookup path");
+#endif // _PY_INT_MORE_LOG
+        free(_lookupPath);
+    }
+}
+
+void TPythonScreens::run()
+{
+    while (1)
+    {
+        if (_terminationFlag)
+        {
+            return;
+        }
+        TTrain *train = (TTrain *)_train;
+        _trainState = train->GetTrainState();
+        if (_terminationFlag)
+        {
+            _freeTrainState();
+            return;
+        }
+        for (std::vector<TPythonScreenRenderer *>::iterator i = _screens.begin();
+             i != _screens.end(); ++i)
+        {
+            (*i)->render(_trainState);
+        }
+        _freeTrainState();
+        if (_terminationFlag)
+        {
+            _cleanup();
+            return;
+        }
+        _renderReadyFlag = true;
+        while (!_cleanupReadyFlag && !_terminationFlag)
+        {
+            Sleep(100);
+        }
+        if (_terminationFlag)
+        {
+            return;
+        }
+        _cleanup();
+    }
+}
+
+void TPythonScreens::finish()
+{
+    _thread == NULL;
+}
+
+DWORD WINAPI ScreenRendererThread(LPVOID lpParam)
+{
+    TPythonScreens *renderer = (TPythonScreens *)lpParam;
+    renderer->run();
+    renderer->finish();
+#ifdef _PY_INT_MORE_LOG
+    WriteLog("Python Screen Renderer Thread Ends");
+#endif // _PY_INT_MORE_LOG
+    return true;
+}
+
+void TPythonScreens::start()
+{
+    if (_screens.size() > 0)
+    {
+        _thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ScreenRendererThread, this,
+                               CREATE_SUSPENDED, &_threadId);
+        if (_thread != NULL)
+        {
+            SetThreadPriority(_thread,
+                              TPythonInterpreter::getInstance()->getScreenRendererPriotity());
+            if (ResumeThread(_thread) != (DWORD)-1)
+            {
+                return;
+            }
+        }
+        WriteLog("Python Screen Renderer Thread Did Not Start");
+    }
+}
+
+void TPythonScreens::_cleanup()
+{
+    _cleanupReadyFlag = false;
+    for (std::vector<TPythonScreenRenderer *>::iterator i = _screens.begin(); i != _screens.end();
+         ++i)
+    {
+        (*i)->cleanup();
+    }
+}
+
+void TPythonScreens::_freeTrainState()
+{
+    if (_trainState != NULL)
+    {
+        PyDict_Clear(_trainState);
+        Py_CLEAR(_trainState);
+        _trainState = NULL;
+    }
+}

PyInt.h

@@ -0,0 +1,95 @@
+#ifndef PyIntH
+#define PyIntH
+
+#undef _DEBUG // bez tego macra Py_DECREF powoduja problemy przy linkowaniu
+
+#include "Python.h"
+#include "QueryParserComp.hpp"
+#include "Model3d.h"
+#include <vector>
+#include <set>
+
+#define PyGetFloat(param) PyFloat_FromDouble(param >= 0 ? param : -param)
+#define PyGetInt(param) PyInt_FromLong(param)
+#define PyGetBool(param) param ? Py_True : Py_False
+
+struct ltstr
+{
+    bool operator()(const char *s1, const char *s2) const
+    {
+        return strcmp(s1, s2) < 0;
+    }
+};
+
+class TPythonInterpreter
+{
+  protected:
+    TPythonInterpreter();
+    ~TPythonInterpreter()
+    {
+    }
+    static TPythonInterpreter *_instance;
+    int _screenRendererPriority;
+    std::set<const char *, ltstr> _classes;
+    PyObject *_main;
+    PyObject *_stdErr;
+    FILE *_getFile(const char *lookupPath, const char *className);
+
+  public:
+    static TPythonInterpreter *getInstance();
+    bool loadClassFile(const char *lookupPath, const char *className);
+    PyObject *newClass(const char *className);
+    PyObject *newClass(const char *className, PyObject *argsTuple);
+    int getScreenRendererPriotity()
+    {
+        return _screenRendererPriority;
+    };
+    void setScreenRendererPriority(const char *priority);
+    void handleError();
+};
+
+class TPythonScreenRenderer
+{
+  protected:
+    PyObject *_pyRenderer;
+    PyObject *_pyTexture;
+    int _textureId;
+    PyObject *_pyWidth;
+    PyObject *_pyHeight;
+
+  public:
+    TPythonScreenRenderer(int textureId, PyObject *renderer);
+    ~TPythonScreenRenderer();
+    void render(PyObject *trainState);
+    void cleanup();
+    void updateTexture();
+};
+
+class TPythonScreens
+{
+  protected:
+    bool _cleanupReadyFlag;
+    bool _renderReadyFlag;
+    bool _terminationFlag;
+    HANDLE _thread;
+    DWORD _threadId;
+    std::vector<TPythonScreenRenderer *> _screens;
+    char *_lookupPath;
+    void *_train;
+    void _cleanup();
+    void _freeTrainState();
+    PyObject *_trainState;
+
+  public:
+    void reset(void *train);
+    void setLookupPath(AnsiString path);
+    void init(TQueryParserComp *parser, TModel3d *model, AnsiString name, int cab);
+    void update();
+    TPythonScreens();
+    ~TPythonScreens();
+    void run();
+    void start();
+    void finish();
+};
+
+#endif // PyIntH

RealSound.cpp

@@ -45,10 +45,12 @@ TRealSound::~TRealSound()
     // if (this) if (pSound) pSound->Stop();
 }
 
-void TRealSound::Free() {}
+void TRealSound::Free()
+{
+}
 
-void TRealSound::Init(char *SoundName, double DistanceAttenuation, double X, double Y,
+void TRealSound::Init(char *SoundName, double DistanceAttenuation, double X, double Y, double Z,
-                                 double Z, bool Dynamic, bool freqmod, double rmin)
+                      bool Dynamic, bool freqmod, double rmin)
 {
     // Nazwa=SoundName; //to tak raczej nie zadziała, (SoundName) jest tymczasowe
     pSound = TSoundsManager::GetFromName(SoundName, Dynamic, &fFrequency);
@@ -95,8 +97,7 @@ double TRealSound::ListenerDistance(vector3 ListenerPosition)
     }
 }
 
-void TRealSound::Play(double Volume, int Looping, bool ListenerInside,
+void TRealSound::Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition)
-                                 vector3 NewPosition)
 {
     if (!pSound)
         return;
@@ -168,7 +169,8 @@ void TRealSound::Play(double Volume, int Looping, bool ListenerInside,
     }
 };
 
-void TRealSound::Start(){// włączenie dźwięku
+void TRealSound::Start(){
+    // włączenie dźwięku
 
 };
 
@@ -185,8 +187,7 @@ void TRealSound::Stop()
         }
 };
 
-void TRealSound::AdjFreq(double Freq,
+void TRealSound::AdjFreq(double Freq, double dt) // McZapkie TODO: dorobic tu efekt Dopplera
-                                    double dt) // McZapkie TODO: dorobic tu efekt Dopplera
 // Freq moze byc liczba dodatnia mniejsza od 1 lub wieksza od 1
 {
     float df, Vlist, Vsrc;
@@ -223,7 +224,10 @@ double TRealSound::GetWaveTime() // McZapkie: na razie tylko dla 22KHz/8bps
            fFrequency; //(pSound->);  // wielkosc w bajtach przez czestotliwosc probkowania
 }
 
-void TRealSound::SetPan(int Pan) { pSound->SetPan(Pan); }
+void TRealSound::SetPan(int Pan)
+{
+    pSound->SetPan(Pan);
+}
 
 int TRealSound::GetStatus()
 {
@@ -243,8 +247,8 @@ void TRealSound::ResetPosition()
         pSound->SetCurrentPosition(0);
 }
 
-void TTextSound::Init(char *SoundName, double SoundAttenuation, double X, double Y,
+void TTextSound::Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z,
-                                 double Z, bool Dynamic, bool freqmod, double rmin)
+                      bool Dynamic, bool freqmod, double rmin)
 { // dodatkowo doczytuje plik tekstowy
     TRealSound::Init(SoundName, SoundAttenuation, X, Y, Z, Dynamic, freqmod, rmin);
     fTime = GetWaveTime();
@@ -264,8 +268,7 @@ void TTextSound::Init(char *SoundName, double SoundAttenuation, double X, double
         delete ts;
     }
 };
-void TTextSound::Play(double Volume, int Looping, bool ListenerInside,
+void TTextSound::Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition)
-                                 vector3 NewPosition)
 {
     if (!asText.IsEmpty())
     { // jeśli ma powiązany tekst

RealSound.h

@@ -32,8 +32,8 @@ class TRealSound
     TRealSound();
     ~TRealSound();
     void Free();
-    void Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z,
+    void Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z, bool Dynamic,
-                         bool Dynamic, bool freqmod = false, double rmin = 0.0);
+              bool freqmod = false, double rmin = 0.0);
     double ListenerDistance(vector3 ListenerPosition);
     void Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition);
     void Start();
@@ -51,8 +51,8 @@ class TTextSound : public TRealSound
     AnsiString asText;
     float fTime; // czas trwania
   public:
-    void Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z,
+    void Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z, bool Dynamic,
-                         bool Dynamic, bool freqmod = false, double rmin = 0.0);
+              bool freqmod = false, double rmin = 0.0);
     void Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition);
 };
 

ResourceManager.cpp

@@ -17,7 +17,10 @@ double ResourceManager::_expiry = 5.0f;
 double ResourceManager::_lastUpdate = 0.0f;
 double ResourceManager::_lastReport = 0.0f;
 
-void ResourceManager::Register(Resource *resource) { _resources.push_back(resource); };
+void ResourceManager::Register(Resource *resource)
+{
+    _resources.push_back(resource);
+};
 
 void ResourceManager::Unregister(Resource *resource)
 {
@@ -33,7 +36,10 @@ class ResourceExpired
 {
   public:
     ResourceExpired(double time) : _time(time){};
-    bool operator()(Resource *resource) { return (resource->GetLastUsage() < _time); }
+    bool operator()(Resource *resource)
+    {
+        return (resource->GetLastUsage() < _time);
+    }
 
   private:
     double _time;

ResourceManager.h

@@ -20,10 +20,16 @@ class Resource
 
   public:
     virtual void Release() = 0;
-    double GetLastUsage() const { return _lastUsage; }
+    double GetLastUsage() const
+    {
+        return _lastUsage;
+    }
 
   protected:
-    void SetLastUsage(double lastUsage) { _lastUsage = lastUsage; }
+    void SetLastUsage(double lastUsage)
+    {
+        _lastUsage = lastUsage;
+    }
 
   private:
     double _lastUsage;
@@ -37,7 +43,10 @@ class ResourceManager
     static void Unregister(Resource *resource);
 
     static void Sweep(double currentTime);
-    static void SetExpiry(double expiry) { _expiry = expiry; }
+    static void SetExpiry(double expiry)
+    {
+        _expiry = expiry;
+    }
 
   private:
     typedef std::vector<Resource *> Resources;

Segment.cpp

@@ -41,10 +41,13 @@ TSegment::TSegment(TTrack *owner)
     pOwner = owner;
 };
 
-TSegment::~TSegment() { SafeDeleteArray(fTsBuffer); };
+TSegment::~TSegment()
+{
+    SafeDeleteArray(fTsBuffer);
+};
 
-bool TSegment::Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep,
+bool TSegment::Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep, double fNewRoll1,
-                               double fNewRoll1, double fNewRoll2)
+                    double fNewRoll2)
 { // wersja dla prostego - wyliczanie punktów kontrolnych
     vector3 dir;
     if (fNewRoll1 == fNewRoll2)
@@ -62,8 +65,8 @@ bool TSegment::Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep,
 };
 
 bool TSegment::Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointIn,
-                               vector3 &NewPoint2, double fNewStep, double fNewRoll1,
+                    vector3 &NewPoint2, double fNewStep, double fNewRoll1, double fNewRoll2,
-                               double fNewRoll2, bool bIsCurve)
+                    bool bIsCurve)
 { // wersja uniwersalna (dla krzywej i prostego)
     Point1 = NewPoint1;
     CPointOut = NewCPointOut;
@@ -329,9 +332,8 @@ vector3 TSegment::FastGetPoint(double t)
     return (bCurve ? RaInterpolate(t) : ((1.0 - t) * Point1 + (t)*Point2));
 }
 
-void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints,
+void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, double fTextureLength,
-                                     double fTextureLength, int iSkip, int iQualityFactor,
+                          int iSkip, int iQualityFactor, vector3 **p, bool bRender)
-                                     vector3 **p, bool bRender)
 { // generowanie trójkątów dla odcinka trajektorii ruchu
     // standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
     // po modyfikacji - dla ujemnego (iNumShapePoints) w dodatkowych polach tabeli
@@ -696,9 +698,8 @@ void TSegment::Render()
     }
 }
 
-void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints,
+void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
-                                       int iNumShapePoints, double fTextureLength, int iSkip,
+                            double fTextureLength, int iSkip, int iEnd, double fOffsetX)
-                                       int iEnd, double fOffsetX)
 { // generowanie trójkątów dla odcinka trajektorii ruchu
     // standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
     // po modyfikacji - dla ujemnego (iNumShapePoints) w dodatkowych polach tabeli
@@ -896,9 +897,8 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints,
     }
 };
 
-void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints,
+void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
-                                    int iNumShapePoints, double fTextureLength, int iSkip, int iEnd,
+                         double fTextureLength, int iSkip, int iEnd, double fOffsetX)
-                                    double fOffsetX)
 { // jak wyżej, tylko z pominięciem mapowania i braku trapezowania
     vector3 pos1, pos2, dir, parallel1, parallel2, pt;
     double s, step, fOffset, t, fEnd;

Segment.h

@@ -77,22 +77,36 @@ class TSegment
     // (0-Bezier,1-prosty,2/3-³uk w lewo/prawo,6/7-przejœciowa w lewo/prawo)
     TSegment(TTrack *owner);
     ~TSegment();
-    bool Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep,
+    bool Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep, double fNewRoll1 = 0,
-                         double fNewRoll1 = 0, double fNewRoll2 = 0);
+              double fNewRoll2 = 0);
-    bool Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointIn,
+    bool Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointIn, vector3 &NewPoint2,
-                         vector3 &NewPoint2, double fNewStep, double fNewRoll1 = 0,
+              double fNewStep, double fNewRoll1 = 0, double fNewRoll2 = 0, bool bIsCurve = true);
-                         double fNewRoll2 = 0, bool bIsCurve = true);
     inline double ComputeLength(); // McZapkie-150503
-    inline vector3 GetDirection1() { return bCurve ? CPointOut - Point1 : CPointOut; };
+    inline vector3 GetDirection1()
-    inline vector3 GetDirection2() { return bCurve ? CPointIn - Point2 : CPointIn; };
+    {
+        return bCurve ? CPointOut - Point1 : CPointOut;
+    };
+    inline vector3 GetDirection2()
+    {
+        return bCurve ? CPointIn - Point2 : CPointIn;
+    };
     vector3 GetDirection(double fDistance);
-    vector3 GetDirection() { return CPointOut; };
+    vector3 GetDirection()
+    {
+        return CPointOut;
+    };
     vector3 FastGetDirection(double fDistance, double fOffset);
     vector3 GetPoint(double fDistance);
     void RaPositionGet(double fDistance, vector3 &p, vector3 &a);
     vector3 FastGetPoint(double t);
-    inline vector3 FastGetPoint_0() { return Point1; };
+    inline vector3 FastGetPoint_0()
-    inline vector3 FastGetPoint_1() { return Point2; };
+    {
+        return Point1;
+    };
+    inline vector3 FastGetPoint_1()
+    {
+        return Point2;
+    };
     inline double GetRoll(double s)
     {
         s /= fLength;
@@ -103,14 +117,16 @@ class TSegment
         r1 = fRoll1;
         r2 = fRoll2;
     }
-    void RenderLoft(const vector6 *ShapePoints, int iNumShapePoints,
+    void RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, double fTextureLength,
-                               double fTextureLength, int iSkip = 0, int iQualityFactor = 1,
+                    int iSkip = 0, int iQualityFactor = 1, vector3 **p = NULL, bool bRender = true);
-                               vector3 **p = NULL, bool bRender = true);
     void RenderSwitchRail(const vector6 *ShapePoints1, const vector6 *ShapePoints2,
                           int iNumShapePoints, double fTextureLength, int iSkip = 0,
                           double fOffsetX = 0.0f);
     void Render();
-    inline double GetLength() { return fLength; };
+    inline double GetLength()
+    {
+        return fLength;
+    };
     void MoveMe(vector3 pPosition)
     {
         Point1 += pPosition;
@@ -121,14 +137,18 @@ class TSegment
             CPointOut += pPosition;
         }
     }
-    int RaSegCount() { return fTsBuffer ? iSegCount : 1; };
+    int RaSegCount()
-    void RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints,
+    {
-                                 int iNumShapePoints, double fTextureLength, int iSkip = 0,
+        return fTsBuffer ? iSegCount : 1;
-                                 int iEnd = 0, double fOffsetX = 0.0);
+    };
+    void RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
+                      double fTextureLength, int iSkip = 0, int iEnd = 0, double fOffsetX = 0.0);
     void RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
-                              double fTextureLength, int iSkip = 0, int iEnd = 0,
+                   double fTextureLength, int iSkip = 0, int iEnd = 0, double fOffsetX = 0.0);
-                              double fOffsetX = 0.0);
+    void AngleSet(int i, double a)
-    void AngleSet(int i, double a) { fAngle[i] = a; };
+    {
+        fAngle[i] = a;
+    };
     void Rollment(double w1, double w2); // poprawianie przechy³ki
 };
 

Sound.cpp

@@ -171,7 +171,10 @@ LPDIRECTSOUNDBUFFER TSoundContainer::GetUnique(LPDIRECTSOUND pDS)
     return DSBuffers.top();
 };
 
-TSoundsManager::~TSoundsManager() { Free(); };
+TSoundsManager::~TSoundsManager()
+{
+    Free();
+};
 
 void TSoundsManager::Free()
 {
@@ -200,8 +203,7 @@ void TSoundsManager::LoadSounds(char *Directory)
     FindClose(handle);
 };
 
-LPDIRECTSOUNDBUFFER TSoundsManager::GetFromName(char *Name, bool Dynamic,
+LPDIRECTSOUNDBUFFER TSoundsManager::GetFromName(char *Name, bool Dynamic, float *fSamplingRate)
-                                                           float *fSamplingRate)
 { // wyszukanie dŸwiêku w pamiêci albo wczytanie z pliku
     AnsiString file;
     if (Dynamic)

Sound.h

@@ -39,8 +39,7 @@ class TSoundContainer
     TSoundContainer *Next;
     std::stack<LPDIRECTSOUNDBUFFER> DSBuffers;
     LPDIRECTSOUNDBUFFER GetUnique(LPDIRECTSOUND pDS);
-    TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName,
+    TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName, int NConcurrent);
-                               int NConcurrent);
     ~TSoundContainer();
 };
 
@@ -62,8 +61,7 @@ class TSoundsManager
     static void Free();
     static void Init(char *Name, int Concurrent);
     static void LoadSounds(char *Directory);
-    static LPDIRECTSOUNDBUFFER GetFromName(char *Name, bool Dynamic,
+    static LPDIRECTSOUNDBUFFER GetFromName(char *Name, bool Dynamic, float *fSamplingRate = NULL);
-                                                      float *fSamplingRate = NULL);
     static void RestoreAll();
 };
 

Spline.cpp

@@ -73,7 +73,9 @@ __fastcall TKnot::TKnot(int n)
     }
 }
 
-__fastcall TKnot::~TKnot() {}
+__fastcall TKnot::~TKnot()
+{
+}
 
 vector3 TKnot::GetDirection(float t)
 {

Spring.cpp

@@ -24,7 +24,9 @@ TSpring::TSpring()
     restLen = 0;
 }
 
-TSpring::~TSpring() {}
+TSpring::~TSpring()
+{
+}
 
 void TSpring::Init(double nrestLen, double nKs, double nKd)
 {
@@ -72,7 +74,9 @@ bool TSpring::ComputateForces(vector3 pPosition1, vector3 pPosition2)
     return true;
 }
 
-void TSpring::Render() {}
+void TSpring::Render()
+{
+}
 
 //---------------------------------------------------------------------------
 

Texture.cpp

@@ -89,7 +89,10 @@ TTexturesManager::Names::iterator TTexturesManager::LoadFromFile(std::string fil
 
 struct ReplaceSlash
 {
-    const char operator()(const char input) { return input == '/' ? '\\' : input; }
+    const char operator()(const char input)
+    {
+        return input == '/' ? '\\' : input;
+    }
 };
 
 GLuint TTexturesManager::GetTextureID(char *dir, char *where, std::string fileName, int filter)

Timer.cpp

@@ -25,7 +25,10 @@ double fSimulationTime = 0;
 double fSoundTimer = 0;
 double fSinceStart = 0;
 
-double GetTime() { return fSimulationTime; }
+double GetTime()
+{
+    return fSimulationTime;
+}
 
 double GetDeltaTime()
 { // czas symulacji (stoi gdy pauza)
@@ -37,19 +40,35 @@ double GetDeltaRenderTime()
     return DeltaRenderTime;
 }
 
-double GetfSinceStart() { return fSinceStart; }
+double GetfSinceStart()
+{
+    return fSinceStart;
+}
 
-void SetDeltaTime(double t) { DeltaTime = t; }
+void SetDeltaTime(double t)
+{
+    DeltaTime = t;
+}
 
-double GetSimulationTime() { return fSimulationTime; }
+double GetSimulationTime()
+{
+    return fSimulationTime;
+}
 
-void SetSimulationTime(double t) { fSimulationTime = t; }
+void SetSimulationTime(double t)
+{
+    fSimulationTime = t;
+}
 
 bool GetSoundTimer()
 { // Ra: byæ mo¿e, by dŸwiêki nie modyfikowa³y siê zbyt czêsto, po 0.1s zeruje siê ten licznik
-  return (fSoundTimer == 0.0f); }
+    return (fSoundTimer == 0.0f);
+}
 
-double GetFPS() { return fFPS; }
+double GetFPS()
+{
+    return fFPS;
+}
 
 void ResetTimers()
 {

Track.cpp

@@ -68,8 +68,8 @@ TSwitchExtension::TSwitchExtension(TTrack *owner, int what)
     Segments[2] = (what >= 3) ?
                       new TSegment(owner) :
                       NULL; // z punktu 2 do 4       skrzyżowanie od góry:      wersja "-1":
-    Segments[3] = (what >= 4) ? new TSegment(owner) :
+    Segments[3] =
-                                NULL; // z punktu 4 do 1              1       1=4          0 0=3
+        (what >= 4) ? new TSegment(owner) : NULL; // z punktu 4 do 1              1       1=4 0 0=3
     Segments[4] =
         (what >= 5) ? new TSegment(owner) : NULL; // z punktu 1 do 3            4 x 3   3 3 x 2   2
     Segments[5] = (what >= 6) ? new TSegment(owner) :
@@ -102,7 +102,8 @@ TIsolated::TIsolated(const AnsiString &n, TIsolated *i)
     pMemCell = NULL; // podpiąć istniejącą albo utworzyć pustą
 };
 
-TIsolated::~TIsolated(){// usuwanie
+TIsolated::~TIsolated(){
+    // usuwanie
     /*
      TIsolated *p=pRoot;
      while (pRoot)

Track.h

@@ -111,9 +111,18 @@ class TIsolated
     static TIsolated *__fastcall Find(
         const AnsiString &n); // znalezienie obiektu albo utworzenie nowego
     void Modify(int i, TDynamicObject *o); // dodanie lub odjęcie osi
-    bool Busy() { return (iAxles > 0); };
+    bool Busy()
-    static TIsolated *__fastcall Root() { return (pRoot); };
+    {
-    TIsolated *__fastcall Next() { return (pNext); };
+        return (iAxles > 0);
+    };
+    static TIsolated *__fastcall Root()
+    {
+        return (pRoot);
+    };
+    TIsolated *__fastcall Next()
+    {
+        return (pNext);
+    };
 };
 
 class TTrack : public Resource
@@ -185,15 +194,30 @@ class TTrack : public Resource
     void Init();
     static TTrack *__fastcall Create400m(int what, double dx);
     TTrack *__fastcall NullCreate(int dir);
-    inline bool IsEmpty() { return (iNumDynamics <= 0); };
+    inline bool IsEmpty()
+    {
+        return (iNumDynamics <= 0);
+    };
     void ConnectPrevPrev(TTrack *pNewPrev, int typ);
     void ConnectPrevNext(TTrack *pNewPrev, int typ);
     void ConnectNextPrev(TTrack *pNewNext, int typ);
     void ConnectNextNext(TTrack *pNewNext, int typ);
-    inline double Length() { return Segment->GetLength(); };
+    inline double Length()
-    inline TSegment *__fastcall CurrentSegment() { return Segment; };
+    {
-    inline TTrack *__fastcall CurrentNext() { return (trNext); };
+        return Segment->GetLength();
-    inline TTrack *__fastcall CurrentPrev() { return (trPrev); };
+    };
+    inline TSegment *__fastcall CurrentSegment()
+    {
+        return Segment;
+    };
+    inline TTrack *__fastcall CurrentNext()
+    {
+        return (trNext);
+    };
+    inline TTrack *__fastcall CurrentPrev()
+    {
+        return (trPrev);
+    };
     TTrack *__fastcall Neightbour(int s, double &d);
     bool SetConnections(int i);
     bool Switch(int i, double t = -1.0, double d = -1.0);
@@ -244,7 +268,10 @@ class TTrack : public Resource
     AnsiString IsolatedName();
     bool IsolatedEventsAssign(TEvent *busy, TEvent *free);
     double WidthTotal();
-    GLuint TextureGet(int i) { return i ? TextureID1 : TextureID2; };
+    GLuint TextureGet(int i)
+    {
+        return i ? TextureID1 : TextureID2;
+    };
     bool IsGroupable();
     int TestPoint(vector3 *Point);
     void MovedUp1(double dh);

TractionPower.cpp

@@ -86,13 +86,15 @@ bool TTractionPowerSource::Load(cParser *parser)
         Error("tractionpowersource end statement missing");
     // if (!bSection) //od³¹cznik sekcji zasadniczo nie ma impedancji (0.01 jest OK)
     if (InternalRes < 0.1) // coœ ma³a ta rezystancja by³a...
-        InternalRes =
+        InternalRes = 0.2; // tak oko³o 0.2, wg
-            0.2; // tak oko³o 0.2, wg
     // http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf
     return true;
 };
 
-bool TTractionPowerSource::Render() { return true; };
+bool TTractionPowerSource::Render()
+{
+    return true;
+};
 
 bool TTractionPowerSource::Update(double dt)
 { // powinno byæ wykonane raz na krok fizyki

TractionPower.h

@@ -48,7 +48,10 @@ class TTractionPowerSource
     bool Render();
     bool Update(double dt);
     double CurrentGet(double res);
-    void VoltageSet(double v) { NominalVoltage = v; };
+    void VoltageSet(double v)
+    {
+        NominalVoltage = v;
+    };
     void PowerSet(TTractionPowerSource *ps);
 };
 

Train.cpp

@@ -49,8 +49,8 @@ TCab::TCab()
     iButtons = 0;
 }
 
-void TCab::Init(double Initx1, double Inity1, double Initz1, double Initx2,
+void TCab::Init(double Initx1, double Inity1, double Initz1, double Initx2, double Inity2,
-                           double Inity2, double Initz2, bool InitEnabled, bool InitOccupied)
+                double Initz2, bool InitEnabled, bool InitOccupied)
 {
     CabPos1.x = Initx1;
     CabPos1.y = Inity1;
@@ -260,6 +260,38 @@ bool TTrain::Init(TDynamicObject *NewDynamicObject, bool e3d)
     return true;
 }
 
+PyObject *TTrain::GetTrainState()
+{
+    PyObject *dict = PyDict_New();
+    if (dict == NULL)
+    {
+        return NULL;
+    }
+
+    PyDict_SetItemString(dict, "direction", PyGetInt(DynamicObject->MoverParameters->ActiveDir));
+    PyDict_SetItemString(dict, "slipping_wheels",
+                         PyGetBool(DynamicObject->MoverParameters->SlippingWheels));
+    PyDict_SetItemString(dict, "converter",
+                         PyGetBool(DynamicObject->MoverParameters->ConverterFlag));
+    PyDict_SetItemString(dict, "main_ctrl_actual_pos",
+                         PyGetInt(DynamicObject->MoverParameters->MainCtrlActualPos));
+    PyDict_SetItemString(dict, "scnd_ctrl_actual_pos",
+                         PyGetInt(DynamicObject->MoverParameters->ScndCtrlActualPos));
+    PyDict_SetItemString(dict, "fuse", PyGetBool(DynamicObject->MoverParameters->FuseFlag));
+    PyDict_SetItemString(dict, "converter_overload",
+                         PyGetBool(DynamicObject->MoverParameters->ConvOvldFlag));
+    PyDict_SetItemString(dict, "voltage", PyGetFloat(DynamicObject->MoverParameters->Voltage));
+    PyDict_SetItemString(dict, "velocity", PyGetFloat(DynamicObject->MoverParameters->Vel));
+    PyDict_SetItemString(dict, "im", PyGetFloat(DynamicObject->MoverParameters->Im));
+    PyDict_SetItemString(dict, "compress",
+                         PyGetBool(DynamicObject->MoverParameters->CompressorFlag));
+    PyDict_SetItemString(dict, "hours", PyGetInt(GlobalTime->hh));
+    PyDict_SetItemString(dict, "minutes", PyGetInt(GlobalTime->mm));
+    PyDict_SetItemString(dict, "seconds", PyGetInt(GlobalTime->mr));
+    PyDict_SetItemString(dict, "velocity_desired", PyGetFloat(DynamicObject->Mechanik->VelDesired));
+    return dict;
+}
+
 void TTrain::OnKeyDown(int cKey)
 { // naciœniêcie klawisza
     bool isEztOer;
@@ -4589,6 +4621,8 @@ bool TTrain::Update()
         ggDepartureSignalButton.UpdateValue(0);
         ggFuseButton.UpdateValue(0);
         ggConverterFuseButton.UpdateValue(0);
+
+        pyScreens.update();
     }
     // wyprowadzenie sygna³ów dla haslera na PoKeys (zaznaczanie na taœmie)
     btHaslerBrakes.Turn(DynamicObject->MoverParameters->BrakePress > 0.4); // ciœnienie w cylindrach
@@ -4902,6 +4936,8 @@ bool TTrain::LoadMMediaFile(AnsiString asFileName)
 
 bool TTrain::InitializeCab(int NewCabNo, AnsiString asFileName)
 {
+    pyScreens.reset(this);
+    pyScreens.setLookupPath(DynamicObject->asBaseDir);
     bool parse = false;
     double dSDist;
     TFileStream *fs;
@@ -5508,6 +5544,8 @@ bool TTrain::InitializeCab(int NewCabNo, AnsiString asFileName)
                 btLampkaBackward.Load(Parser, DynamicObject->mdKabina);
             else if (str == AnsiString("i-cablight:")) // hunter-171012
                 btCabLight.Load(Parser, DynamicObject->mdKabina);
+            else if (str == AnsiString("pyscreen:"))
+                pyScreens.init(Parser, DynamicObject->mdKabina, DynamicObject->GetName(), NewCabNo);
             // btLampkaUnknown.Init("unknown",mdKabina,false);
         }
     }
@@ -5518,6 +5556,7 @@ bool TTrain::InitializeCab(int NewCabNo, AnsiString asFileName)
     }
     // ABu 050205: tego wczesniej nie bylo:
     delete Parser;
+    pyScreens.start();
     if (DynamicObject->mdKabina)
     {
         DynamicObject->mdKabina

Train.h

@@ -23,6 +23,7 @@ http://mozilla.org/MPL/2.0/.
 #include "AdvSound.h"
 #include "RealSound.h"
 #include "FadeSound.h"
+#include "PyInt.h"
 
 // typedef enum {st_Off, st_Starting, st_On, st_ShuttingDown} T4State;
 
@@ -83,14 +84,21 @@ class TTrain
 
     //    bool SHP() { fShpTimer= 0; };
 
-    inline vector3 GetDirection() { return DynamicObject->VectorFront(); };
+    inline vector3 GetDirection()
-    inline vector3 GetUp() { return DynamicObject->VectorUp(); };
+    {
+        return DynamicObject->VectorFront();
+    };
+    inline vector3 GetUp()
+    {
+        return DynamicObject->VectorUp();
+    };
     void UpdateMechPosition(double dt);
     bool Update();
     void MechStop();
     //    virtual bool RenderAlpha();
     // McZapkie-310302: ladowanie parametrow z pliku
     bool LoadMMediaFile(AnsiString asFileName);
+    PyObject *GetTrainState();
 
   private: //瞠by go nic z zewn靖rz nie przestawia這
     TDynamicObject *DynamicObject; // przestawia zmiana pojazdu [F5]
@@ -372,10 +380,21 @@ class TTrain
     float fSPPress, fSNPress;
     int iSekunda; // Ra: sekunda aktualizacji pr璠ko𦣇i
     int iRadioChannel; // numer aktualnego kana逝 radiowego
+    TPythonScreens pyScreens;
+
   public:
-    int RadioChannel() { return iRadioChannel; };
+    int RadioChannel()
-    inline TDynamicObject *__fastcall Dynamic() { return DynamicObject; };
+    {
-    inline TMoverParameters *__fastcall Controlled() { return mvControlled; };
+        return iRadioChannel;
+    };
+    inline TDynamicObject *__fastcall Dynamic()
+    {
+        return DynamicObject;
+    };
+    inline TMoverParameters *__fastcall Controlled()
+    {
+        return mvControlled;
+    };
     void DynamicSet(TDynamicObject *d);
     void Silence();
 };

TrkFoll.cpp

@@ -37,7 +37,9 @@ TTrackFollower::TTrackFollower()
     fOffsetH = 0.0; // na starcie stoi na środku
 }
 
-TTrackFollower::~TTrackFollower() {}
+TTrackFollower::~TTrackFollower()
+{
+}
 
 bool TTrackFollower::Init(TTrack *pTrack, TDynamicObject *NewOwner, double fDir)
 {

TrkFoll.h

@@ -35,14 +35,23 @@ class TTrackFollower
     ~TTrackFollower();
     TTrack *__fastcall SetCurrentTrack(TTrack *pTrack, int end);
     bool Move(double fDistance, bool bPrimary);
-    inline TTrack *__fastcall GetTrack() { return pCurrentTrack; };
+    inline TTrack *__fastcall GetTrack()
+    {
+        return pCurrentTrack;
+    };
     inline double GetRoll()
     {
         return vAngles.x;
     }; // przechy³ka policzona przy ustalaniu pozycji
     //{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyæ mo¿na pobraæ
-    inline double GetDirection() { return fDirection; }; // zwrot na torze
+    inline double GetDirection()
-    inline double GetTranslation() { return fCurrentDistance; }; // ABu-030403
+    {
+        return fDirection;
+    }; // zwrot na torze
+    inline double GetTranslation()
+    {
+        return fCurrentDistance;
+    }; // ABu-030403
     // inline double GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2)
     //{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); };
     // inline double GetRadius(double L, double d);  //McZapkie-150503

World.cpp

@@ -404,7 +404,8 @@ bool TWorld::Init(HWND NhWnd, HDC hDC)
     glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode
     WriteLog("glFogfv(GL_FOG_COLOR, FogColor);");
     glFogfv(GL_FOG_COLOR, FogColor); // Set Fog Color
-    //	glFogf(GL_FOG_DENSITY, 0.594f);						// How Dense Will The Fog
+    //	glFogf(GL_FOG_DENSITY, 0.594f);						// How Dense Will The
+    //Fog
     // Be
     //	glHint(GL_FOG_HINT, GL_NICEST);					    // Fog Hint Value
     WriteLog("glFogf(GL_FOG_START, 1000.0f);");
@@ -2430,8 +2431,7 @@ bool TWorld::Update()
                                 glColor3f(0.0f, 1.0f, 0.0f); // zielone
                                 glRasterPos2f(
                                     -0.25f,
-                                    0.18f -
+                                    0.18f - 0.02f * (i - tmp->Mechanik->iStationStart)); // dopiero
-                                        0.02f * (i - tmp->Mechanik->iStationStart)); // dopiero
                                 // ustawienie
                                 // pozycji
                                 // ustala

dumb3d.cpp

@@ -49,7 +49,10 @@ void inline vector3::SafeNormalize()
 }
 
 // From code in Graphics Gems; p. 766
-inline scalar_t det2x2(scalar_t a, scalar_t b, scalar_t c, scalar_t d) { return a * d - b * c; }
+inline scalar_t det2x2(scalar_t a, scalar_t b, scalar_t c, scalar_t d)
+{
+    return a * d - b * c;
+}
 
 inline scalar_t det3x3(scalar_t a1, scalar_t a2, scalar_t a3, scalar_t b1, scalar_t b2, scalar_t b3,
                        scalar_t c1, scalar_t c2, scalar_t c3)
@@ -390,7 +393,8 @@ int main(int, char *[])
     Testmatrix4x4();
     matrixFailures = failures;
 
-    cout << endl << "****************************************" << endl;
+    cout << endl
+         << "****************************************" << endl;
     cout << "*                                      *" << endl;
     if (vectorFailures + matrixFailures == 0)
         cout << "*    No failures detected in Math3D    *" << endl;

dumb3d.h

@@ -27,15 +27,26 @@ namespace Math3D
 typedef double scalar_t;
 // inline pass-throughs to various basic math functions
 // written in this style to allow for easy substitution with more efficient versions
-inline scalar_t SINE_FUNCTION(scalar_t x) { return sin(x); }
+inline scalar_t SINE_FUNCTION(scalar_t x)
-inline scalar_t COSINE_FUNCTION(scalar_t x) { return cos(x); }
+{
-inline scalar_t SQRT_FUNCTION(scalar_t x) { return sqrt(x); }
+    return sin(x);
+}
+inline scalar_t COSINE_FUNCTION(scalar_t x)
+{
+    return cos(x);
+}
+inline scalar_t SQRT_FUNCTION(scalar_t x)
+{
+    return sqrt(x);
+}
 
 // 2 element vector
 class vector2
 {
   public:
-    vector2(void) {}
+    vector2(void)
+    {
+    }
     vector2(scalar_t a, scalar_t b)
     {
         x = a;
@@ -52,7 +63,9 @@ class vector2
 class vector3
 {
   public:
-    vector3(void) {}
+    vector3(void)
+    {
+    }
     vector3(scalar_t a, scalar_t b, scalar_t c)
     {
         x = a;
@@ -71,15 +84,24 @@ class vector3
     void inline Normalize();
     void inline SafeNormalize();
     double inline Length();
-    void inline Zero() { x = y = z = 0.0; };
+    void inline Zero()
+    {
+        x = y = z = 0.0;
+    };
 
     // [] is to read, () is to write (const correctness)
     //	const scalar_t& operator[] (int i) const { return e[i]; }
     //	scalar_t& operator() (int i) { return e[i]; }
 
     // Provides access to the underlying array; useful for passing this class off to C APIs
-    const scalar_t *readArray(void) { return &x; }
+    const scalar_t *readArray(void)
-    scalar_t *getArray(void) { return &x; }
+    {
+        return &x;
+    }
+    scalar_t *getArray(void)
+    {
+        return &x;
+    }
 
     //    union
     //  {
@@ -107,7 +129,9 @@ class vector3
 class matrix4x4
 {
   public:
-    matrix4x4(void) {}
+    matrix4x4(void)
+    {
+    }
 
     // When defining matrices in C arrays, it is easiest to define them with
     // the column increasing fastest.  However, some APIs (OpenGL in particular) do this
@@ -130,12 +154,24 @@ class matrix4x4
 
     // [] is to read, () is to write (const correctness)
     // m[x][y] or m(x)[y] is the correct form
-    const scalar_t *operator[](int i) const { return &e[i << 2]; }
+    const scalar_t *operator[](int i) const
-    scalar_t *operator()(int i) { return &e[i << 2]; }
+    {
+        return &e[i << 2];
+    }
+    scalar_t *operator()(int i)
+    {
+        return &e[i << 2];
+    }
 
     // Low-level access to the array.
-    const scalar_t *readArray(void) { return e; }
+    const scalar_t *readArray(void)
-    scalar_t *getArray(void) { return e; }
+    {
+        return e;
+    }
+    scalar_t *getArray(void)
+    {
+        return e;
+    }
 
     // Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX!
     // Written this way to work in-place and hence be somewhat more efficient
@@ -263,14 +299,20 @@ inline bool operator<(const vector3 &v1, const vector3 &v2)
     return false;
 }
 
-inline vector3 operator-(const vector3 &v) { return vector3(-v.x, -v.y, -v.z); }
+inline vector3 operator-(const vector3 &v)
+{
+    return vector3(-v.x, -v.y, -v.z);
+}
 
 inline vector3 operator*(const vector3 &v, scalar_t k)
 {
     return vector3(k * v.x, k * v.y, k * v.z);
 }
 
-inline vector3 operator*(scalar_t k, const vector3 &v) { return v * k; }
+inline vector3 operator*(scalar_t k, const vector3 &v)
+{
+    return v * k;
+}
 
 inline vector3 &operator*=(vector3 &v, scalar_t k)
 {
@@ -293,11 +335,23 @@ inline vector3 &operator/=(vector3 &v, scalar_t k)
     return v;
 }
 
-inline scalar_t LengthSquared3(const vector3 &v) { return DotProduct(v, v); }
+inline scalar_t LengthSquared3(const vector3 &v)
-inline scalar_t LengthSquared4(const vector3 &v) { return DotProduct4(v, v); }
+{
+    return DotProduct(v, v);
+}
+inline scalar_t LengthSquared4(const vector3 &v)
+{
+    return DotProduct4(v, v);
+}
 
-inline scalar_t Length3(const vector3 &v) { return SQRT_FUNCTION(LengthSquared3(v)); }
+inline scalar_t Length3(const vector3 &v)
-inline scalar_t Length4(const vector3 &v) { return SQRT_FUNCTION(LengthSquared4(v)); }
+{
+    return SQRT_FUNCTION(LengthSquared3(v));
+}
+inline scalar_t Length4(const vector3 &v)
+{
+    return SQRT_FUNCTION(LengthSquared4(v));
+}
 
 inline vector3 Normalize(const vector3 &v)
 {
@@ -314,7 +368,10 @@ inline vector3 SafeNormalize(const vector3 &v)
         retVal = v / l;
     return retVal;
 }
-inline vector3 Normalize4(const vector3 &v) { return v / Length4(v); }
+inline vector3 Normalize4(const vector3 &v)
+{
+    return v / Length4(v);
+}
 
 inline vector3 operator+(const vector3 &v1, const vector3 &v2)
 {
@@ -372,7 +429,10 @@ void inline vector3::Normalize()
     z *= il;
 }
 
-double inline vector3::Length() { return SQRT_FUNCTION(x * x + y * y + z * z); }
+double inline vector3::Length()
+{
+    return SQRT_FUNCTION(x * x + y * y + z * z);
+}
 
 inline bool operator==(const matrix4x4 &m1, const matrix4x4 &m2)
 {

geometry.cpp

@@ -11,7 +11,10 @@ http://mozilla.org/MPL/2.0/.
 
 #include "Geometry.h"
 
-inline double sqr(double a) { return (a * a); };
+inline double sqr(double a)
+{
+    return (a * a);
+};
 
 __fastcall TLine::TLine(){};
 
@@ -23,7 +26,10 @@ __fastcall TLine::TLine(vector3 NPoint, vector3 NVector)
 
 __fastcall TLine::~TLine(){};
 
-TPlane TLine::GetPlane() { return (TPlane(Point, Vector)); };
+TPlane TLine::GetPlane()
+{
+    return (TPlane(Point, Vector));
+};
 
 double TLine::GetDistance(vector3 Point1)
 {
@@ -80,11 +86,17 @@ double TPlane::GetSide(vector3 Point)
 //    D3DMath_VectorMatrixMultiply(Vector,src,Transformations);
 //};
 
-bool TPlane::Defined() { return !(Vector == vector3(0, 0, 0)); };
+bool TPlane::Defined()
+{
+    return !(Vector == vector3(0, 0, 0));
+};
 
 //---------------------------------------------------------------------------
 
-inline double Sum(vector3 &Vector) { return (Vector.x + Vector.y + Vector.z); };
+inline double Sum(vector3 &Vector)
+{
+    return (Vector.x + Vector.y + Vector.z);
+};
 
 bool CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane)
 {
@@ -96,7 +108,10 @@ bool CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane)
     return (true);
 };
 
-inline double GetLength(vector3 &Vector) { return (Vector.Length()); };
+inline double GetLength(vector3 &Vector)
+{
+    return (Vector.Length());
+};
 
 inline vector3 SetLength(vector3 &Vector, double Length)
 {

parser.h

@@ -42,15 +42,27 @@ class cParser : public std::stringstream
         getTokens();
         *this >> output;
     };
-    inline void ignoreToken() { readToken(); };
+    inline void ignoreToken()
+    {
+        readToken();
+    };
     inline void ignoreTokens(int count)
     {
         for (int i = 0; i < count; i++)
             readToken();
     };
-    inline bool expectToken(std::string value) { return readToken() == value; };
+    inline bool expectToken(std::string value)
-    bool eof() { return mStream->eof(); };
+    {
-    bool ok() { return !mStream->fail(); };
+        return readToken() == value;
+    };
+    bool eof()
+    {
+        return mStream->eof();
+    };
+    bool ok()
+    {
+        return !mStream->fail();
+    };
     bool getTokens(int Count = 1, bool ToLower = true, const char *Break = "\n\t ;");
     int getProgress() const; // percentage of file processed.
     // load traction?

python/include/Python-ast.h

@@ -0,0 +1,535 @@
+/* File automatically generated by Parser/asdl_c.py. */
+
+#include "asdl.h"
+
+typedef struct _mod *mod_ty;
+
+typedef struct _stmt *stmt_ty;
+
+typedef struct _expr *expr_ty;
+
+typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5,
+                             Param=6 } expr_context_ty;
+
+typedef struct _slice *slice_ty;
+
+typedef enum _boolop { And=1, Or=2 } boolop_ty;
+
+typedef enum _operator { Add=1, Sub=2, Mult=3, Div=4, Mod=5, Pow=6, LShift=7,
+                         RShift=8, BitOr=9, BitXor=10, BitAnd=11, FloorDiv=12 }
+                         operator_ty;
+
+typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty;
+
+typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8,
+                      In=9, NotIn=10 } cmpop_ty;
+
+typedef struct _comprehension *comprehension_ty;
+
+typedef struct _excepthandler *excepthandler_ty;
+
+typedef struct _arguments *arguments_ty;
+
+typedef struct _keyword *keyword_ty;
+
+typedef struct _alias *alias_ty;
+
+
+enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
+                 Suite_kind=4};
+struct _mod {
+        enum _mod_kind kind;
+        union {
+                struct {
+                        asdl_seq *body;
+                } Module;
+                
+                struct {
+                        asdl_seq *body;
+                } Interactive;
+                
+                struct {
+                        expr_ty body;
+                } Expression;
+                
+                struct {
+                        asdl_seq *body;
+                } Suite;
+                
+        } v;
+};
+
+enum _stmt_kind {FunctionDef_kind=1, ClassDef_kind=2, Return_kind=3,
+                  Delete_kind=4, Assign_kind=5, AugAssign_kind=6, Print_kind=7,
+                  For_kind=8, While_kind=9, If_kind=10, With_kind=11,
+                  Raise_kind=12, TryExcept_kind=13, TryFinally_kind=14,
+                  Assert_kind=15, Import_kind=16, ImportFrom_kind=17,
+                  Exec_kind=18, Global_kind=19, Expr_kind=20, Pass_kind=21,
+                  Break_kind=22, Continue_kind=23};
+struct _stmt {
+        enum _stmt_kind kind;
+        union {
+                struct {
+                        identifier name;
+                        arguments_ty args;
+                        asdl_seq *body;
+                        asdl_seq *decorator_list;
+                } FunctionDef;
+                
+                struct {
+                        identifier name;
+                        asdl_seq *bases;
+                        asdl_seq *body;
+                        asdl_seq *decorator_list;
+                } ClassDef;
+                
+                struct {
+                        expr_ty value;
+                } Return;
+                
+                struct {
+                        asdl_seq *targets;
+                } Delete;
+                
+                struct {
+                        asdl_seq *targets;
+                        expr_ty value;
+                } Assign;
+                
+                struct {
+                        expr_ty target;
+                        operator_ty op;
+                        expr_ty value;
+                } AugAssign;
+                
+                struct {
+                        expr_ty dest;
+                        asdl_seq *values;
+                        bool nl;
+                } Print;
+                
+                struct {
+                        expr_ty target;
+                        expr_ty iter;
+                        asdl_seq *body;
+                        asdl_seq *orelse;
+                } For;
+                
+                struct {
+                        expr_ty test;
+                        asdl_seq *body;
+                        asdl_seq *orelse;
+                } While;
+                
+                struct {
+                        expr_ty test;
+                        asdl_seq *body;
+                        asdl_seq *orelse;
+                } If;
+                
+                struct {
+                        expr_ty context_expr;
+                        expr_ty optional_vars;
+                        asdl_seq *body;
+                } With;
+                
+                struct {
+                        expr_ty type;
+                        expr_ty inst;
+                        expr_ty tback;
+                } Raise;
+                
+                struct {
+                        asdl_seq *body;
+                        asdl_seq *handlers;
+                        asdl_seq *orelse;
+                } TryExcept;
+                
+                struct {
+                        asdl_seq *body;
+                        asdl_seq *finalbody;
+                } TryFinally;
+                
+                struct {
+                        expr_ty test;
+                        expr_ty msg;
+                } Assert;
+                
+                struct {
+                        asdl_seq *names;
+                } Import;
+                
+                struct {
+                        identifier module;
+                        asdl_seq *names;
+                        int level;
+                } ImportFrom;
+                
+                struct {
+                        expr_ty body;
+                        expr_ty globals;
+                        expr_ty locals;
+                } Exec;
+                
+                struct {
+                        asdl_seq *names;
+                } Global;
+                
+                struct {
+                        expr_ty value;
+                } Expr;
+                
+        } v;
+        int lineno;
+        int col_offset;
+};
+
+enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4,
+                  IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8,
+                  SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11,
+                  Yield_kind=12, Compare_kind=13, Call_kind=14, Repr_kind=15,
+                  Num_kind=16, Str_kind=17, Attribute_kind=18,
+                  Subscript_kind=19, Name_kind=20, List_kind=21, Tuple_kind=22};
+struct _expr {
+        enum _expr_kind kind;
+        union {
+                struct {
+                        boolop_ty op;
+                        asdl_seq *values;
+                } BoolOp;
+                
+                struct {
+                        expr_ty left;
+                        operator_ty op;
+                        expr_ty right;
+                } BinOp;
+                
+                struct {
+                        unaryop_ty op;
+                        expr_ty operand;
+                } UnaryOp;
+                
+                struct {
+                        arguments_ty args;
+                        expr_ty body;
+                } Lambda;
+                
+                struct {
+                        expr_ty test;
+                        expr_ty body;
+                        expr_ty orelse;
+                } IfExp;
+                
+                struct {
+                        asdl_seq *keys;
+                        asdl_seq *values;
+                } Dict;
+                
+                struct {
+                        asdl_seq *elts;
+                } Set;
+                
+                struct {
+                        expr_ty elt;
+                        asdl_seq *generators;
+                } ListComp;
+                
+                struct {
+                        expr_ty elt;
+                        asdl_seq *generators;
+                } SetComp;
+                
+                struct {
+                        expr_ty key;
+                        expr_ty value;
+                        asdl_seq *generators;
+                } DictComp;
+                
+                struct {
+                        expr_ty elt;
+                        asdl_seq *generators;
+                } GeneratorExp;
+                
+                struct {
+                        expr_ty value;
+                } Yield;
+                
+                struct {
+                        expr_ty left;
+                        asdl_int_seq *ops;
+                        asdl_seq *comparators;
+                } Compare;
+                
+                struct {
+                        expr_ty func;
+                        asdl_seq *args;
+                        asdl_seq *keywords;
+                        expr_ty starargs;
+                        expr_ty kwargs;
+                } Call;
+                
+                struct {
+                        expr_ty value;
+                } Repr;
+                
+                struct {
+                        object n;
+                } Num;
+                
+                struct {
+                        string s;
+                } Str;
+                
+                struct {
+                        expr_ty value;
+                        identifier attr;
+                        expr_context_ty ctx;
+                } Attribute;
+                
+                struct {
+                        expr_ty value;
+                        slice_ty slice;
+                        expr_context_ty ctx;
+                } Subscript;
+                
+                struct {
+                        identifier id;
+                        expr_context_ty ctx;
+                } Name;
+                
+                struct {
+                        asdl_seq *elts;
+                        expr_context_ty ctx;
+                } List;
+                
+                struct {
+                        asdl_seq *elts;
+                        expr_context_ty ctx;
+                } Tuple;
+                
+        } v;
+        int lineno;
+        int col_offset;
+};
+
+enum _slice_kind {Ellipsis_kind=1, Slice_kind=2, ExtSlice_kind=3, Index_kind=4};
+struct _slice {
+        enum _slice_kind kind;
+        union {
+                struct {
+                        expr_ty lower;
+                        expr_ty upper;
+                        expr_ty step;
+                } Slice;
+                
+                struct {
+                        asdl_seq *dims;
+                } ExtSlice;
+                
+                struct {
+                        expr_ty value;
+                } Index;
+                
+        } v;
+};
+
+struct _comprehension {
+        expr_ty target;
+        expr_ty iter;
+        asdl_seq *ifs;
+};
+
+enum _excepthandler_kind {ExceptHandler_kind=1};
+struct _excepthandler {
+        enum _excepthandler_kind kind;
+        union {
+                struct {
+                        expr_ty type;
+                        expr_ty name;
+                        asdl_seq *body;
+                } ExceptHandler;
+                
+        } v;
+        int lineno;
+        int col_offset;
+};
+
+struct _arguments {
+        asdl_seq *args;
+        identifier vararg;
+        identifier kwarg;
+        asdl_seq *defaults;
+};
+
+struct _keyword {
+        identifier arg;
+        expr_ty value;
+};
+
+struct _alias {
+        identifier name;
+        identifier asname;
+};
+
+
+#define Module(a0, a1) _Py_Module(a0, a1)
+mod_ty _Py_Module(asdl_seq * body, PyArena *arena);
+#define Interactive(a0, a1) _Py_Interactive(a0, a1)
+mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena);
+#define Expression(a0, a1) _Py_Expression(a0, a1)
+mod_ty _Py_Expression(expr_ty body, PyArena *arena);
+#define Suite(a0, a1) _Py_Suite(a0, a1)
+mod_ty _Py_Suite(asdl_seq * body, PyArena *arena);
+#define FunctionDef(a0, a1, a2, a3, a4, a5, a6) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6)
+stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body,
+                        asdl_seq * decorator_list, int lineno, int col_offset,
+                        PyArena *arena);
+#define ClassDef(a0, a1, a2, a3, a4, a5, a6) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6)
+stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * body,
+                     asdl_seq * decorator_list, int lineno, int col_offset,
+                     PyArena *arena);
+#define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3)
+stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena);
+#define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3)
+stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena
+                   *arena);
+#define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4)
+stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int
+                   col_offset, PyArena *arena);
+#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
+                      lineno, int col_offset, PyArena *arena);
+#define Print(a0, a1, a2, a3, a4, a5) _Py_Print(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Print(expr_ty dest, asdl_seq * values, bool nl, int lineno, int
+                  col_offset, PyArena *arena);
+#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6)
+stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq *
+                orelse, int lineno, int col_offset, PyArena *arena);
+#define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
+                  int col_offset, PyArena *arena);
+#define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno,
+               int col_offset, PyArena *arena);
+#define With(a0, a1, a2, a3, a4, a5) _Py_With(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_With(expr_ty context_expr, expr_ty optional_vars, asdl_seq * body,
+                 int lineno, int col_offset, PyArena *arena);
+#define Raise(a0, a1, a2, a3, a4, a5) _Py_Raise(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Raise(expr_ty type, expr_ty inst, expr_ty tback, int lineno, int
+                  col_offset, PyArena *arena);
+#define TryExcept(a0, a1, a2, a3, a4, a5) _Py_TryExcept(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_TryExcept(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse,
+                      int lineno, int col_offset, PyArena *arena);
+#define TryFinally(a0, a1, a2, a3, a4) _Py_TryFinally(a0, a1, a2, a3, a4)
+stmt_ty _Py_TryFinally(asdl_seq * body, asdl_seq * finalbody, int lineno, int
+                       col_offset, PyArena *arena);
+#define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4)
+stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset,
+                   PyArena *arena);
+#define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3)
+stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena
+                   *arena);
+#define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int
+                       lineno, int col_offset, PyArena *arena);
+#define Exec(a0, a1, a2, a3, a4, a5) _Py_Exec(a0, a1, a2, a3, a4, a5)
+stmt_ty _Py_Exec(expr_ty body, expr_ty globals, expr_ty locals, int lineno, int
+                 col_offset, PyArena *arena);
+#define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3)
+stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena
+                   *arena);
+#define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3)
+stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena);
+#define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2)
+stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena);
+#define Break(a0, a1, a2) _Py_Break(a0, a1, a2)
+stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena);
+#define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2)
+stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena);
+#define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4)
+expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset,
+                   PyArena *arena);
+#define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int
+                  col_offset, PyArena *arena);
+#define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4)
+expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset,
+                    PyArena *arena);
+#define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4)
+expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset,
+                   PyArena *arena);
+#define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int
+                  col_offset, PyArena *arena);
+#define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4)
+expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int
+                 col_offset, PyArena *arena);
+#define Set(a0, a1, a2, a3) _Py_Set(a0, a1, a2, a3)
+expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena);
+#define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4)
+expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int
+                     col_offset, PyArena *arena);
+#define SetComp(a0, a1, a2, a3, a4) _Py_SetComp(a0, a1, a2, a3, a4)
+expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int
+                    col_offset, PyArena *arena);
+#define DictComp(a0, a1, a2, a3, a4, a5) _Py_DictComp(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int
+                     lineno, int col_offset, PyArena *arena);
+#define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4)
+expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int
+                         col_offset, PyArena *arena);
+#define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3)
+expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena);
+#define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators,
+                    int lineno, int col_offset, PyArena *arena);
+#define Call(a0, a1, a2, a3, a4, a5, a6, a7) _Py_Call(a0, a1, a2, a3, a4, a5, a6, a7)
+expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, expr_ty
+                 starargs, expr_ty kwargs, int lineno, int col_offset, PyArena
+                 *arena);
+#define Repr(a0, a1, a2, a3) _Py_Repr(a0, a1, a2, a3)
+expr_ty _Py_Repr(expr_ty value, int lineno, int col_offset, PyArena *arena);
+#define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3)
+expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena);
+#define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3)
+expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena);
+#define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int
+                      lineno, int col_offset, PyArena *arena);
+#define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5)
+expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int
+                      lineno, int col_offset, PyArena *arena);
+#define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4)
+expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int
+                 col_offset, PyArena *arena);
+#define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4)
+expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+                 col_offset, PyArena *arena);
+#define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4)
+expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int
+                  col_offset, PyArena *arena);
+#define Ellipsis(a0) _Py_Ellipsis(a0)
+slice_ty _Py_Ellipsis(PyArena *arena);
+#define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3)
+slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena);
+#define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1)
+slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena);
+#define Index(a0, a1) _Py_Index(a0, a1)
+slice_ty _Py_Index(expr_ty value, PyArena *arena);
+#define comprehension(a0, a1, a2, a3) _Py_comprehension(a0, a1, a2, a3)
+comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq *
+                                   ifs, PyArena *arena);
+#define ExceptHandler(a0, a1, a2, a3, a4, a5) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5)
+excepthandler_ty _Py_ExceptHandler(expr_ty type, expr_ty name, asdl_seq * body,
+                                   int lineno, int col_offset, PyArena *arena);
+#define arguments(a0, a1, a2, a3, a4) _Py_arguments(a0, a1, a2, a3, a4)
+arguments_ty _Py_arguments(asdl_seq * args, identifier vararg, identifier
+                           kwarg, asdl_seq * defaults, PyArena *arena);
+#define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2)
+keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena);
+#define alias(a0, a1, a2) _Py_alias(a0, a1, a2)
+alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena);
+
+PyObject* PyAST_mod2obj(mod_ty t);
+mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode);
+int PyAST_Check(PyObject* obj);

python/include/Python.h

@@ -0,0 +1,178 @@
+#ifndef Py_PYTHON_H
+#define Py_PYTHON_H
+/* Since this is a "meta-include" file, no #ifdef __cplusplus / extern "C" { */
+
+/* Include nearly all Python header files */
+
+#include "patchlevel.h"
+#include "pyconfig.h"
+#include "pymacconfig.h"
+
+/* Cyclic gc is always enabled, starting with release 2.3a1.  Supply the
+ * old symbol for the benefit of extension modules written before then
+ * that may be conditionalizing on it.  The core doesn't use it anymore.
+ */
+#ifndef WITH_CYCLE_GC
+#define WITH_CYCLE_GC 1
+#endif
+
+#include <limits.h>
+
+#ifndef UCHAR_MAX
+#error "Something's broken.  UCHAR_MAX should be defined in limits.h."
+#endif
+
+#if UCHAR_MAX != 255
+#error "Python's source code assumes C's unsigned char is an 8-bit type."
+#endif
+
+#if defined(__sgi) && defined(WITH_THREAD) && !defined(_SGI_MP_SOURCE)
+#define _SGI_MP_SOURCE
+#endif
+
+#include <stdio.h>
+#ifndef NULL
+#   error "Python.h requires that stdio.h define NULL."
+#endif
+
+#include <string.h>
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+#include <stdlib.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+/* For size_t? */
+#ifdef HAVE_STDDEF_H
+#include <stddef.h>
+#endif
+
+/* CAUTION:  Build setups should ensure that NDEBUG is defined on the
+ * compiler command line when building Python in release mode; else
+ * assert() calls won't be removed.
+ */
+#include <assert.h>
+
+#include "pyport.h"
+
+/* pyconfig.h or pyport.h may or may not define DL_IMPORT */
+#ifndef DL_IMPORT	/* declarations for DLL import/export */
+#define DL_IMPORT(RTYPE) RTYPE
+#endif
+#ifndef DL_EXPORT	/* declarations for DLL import/export */
+#define DL_EXPORT(RTYPE) RTYPE
+#endif
+
+/* Debug-mode build with pymalloc implies PYMALLOC_DEBUG.
+ *  PYMALLOC_DEBUG is in error if pymalloc is not in use.
+ */
+#if defined(Py_DEBUG) && defined(WITH_PYMALLOC) && !defined(PYMALLOC_DEBUG)
+#define PYMALLOC_DEBUG
+#endif
+#if defined(PYMALLOC_DEBUG) && !defined(WITH_PYMALLOC)
+#error "PYMALLOC_DEBUG requires WITH_PYMALLOC"
+#endif
+#include "pymath.h"
+#include "pymem.h"
+
+#include "object.h"
+#include "objimpl.h"
+
+#include "pydebug.h"
+
+#include "unicodeobject.h"
+#include "intobject.h"
+#include "boolobject.h"
+#include "longobject.h"
+#include "floatobject.h"
+#ifndef WITHOUT_COMPLEX
+#include "complexobject.h"
+#endif
+#include "rangeobject.h"
+#include "stringobject.h"
+#include "memoryobject.h"
+#include "bufferobject.h"
+#include "bytesobject.h"
+#include "bytearrayobject.h"
+#include "tupleobject.h"
+#include "listobject.h"
+#include "dictobject.h"
+#include "enumobject.h"
+#include "setobject.h"
+#include "methodobject.h"
+#include "moduleobject.h"
+#include "funcobject.h"
+#include "classobject.h"
+#include "fileobject.h"
+#include "cobject.h"
+#include "pycapsule.h"
+#include "traceback.h"
+#include "sliceobject.h"
+#include "cellobject.h"
+#include "iterobject.h"
+#include "genobject.h"
+#include "descrobject.h"
+#include "warnings.h"
+#include "weakrefobject.h"
+
+#include "codecs.h"
+#include "pyerrors.h"
+
+#include "pystate.h"
+
+#include "pyarena.h"
+#include "modsupport.h"
+#include "pythonrun.h"
+#include "ceval.h"
+#include "sysmodule.h"
+#include "intrcheck.h"
+#include "import.h"
+
+#include "abstract.h"
+
+#include "compile.h"
+#include "eval.h"
+
+#include "pyctype.h"
+#include "pystrtod.h"
+#include "pystrcmp.h"
+#include "dtoa.h"
+
+/* _Py_Mangle is defined in compile.c */
+PyAPI_FUNC(PyObject*) _Py_Mangle(PyObject *p, PyObject *name);
+
+/* PyArg_GetInt is deprecated and should not be used, use PyArg_Parse(). */
+#define PyArg_GetInt(v, a)	PyArg_Parse((v), "i", (a))
+
+/* PyArg_NoArgs should not be necessary.
+   Set ml_flags in the PyMethodDef to METH_NOARGS. */
+#define PyArg_NoArgs(v)		PyArg_Parse(v, "")
+
+/* Argument must be a char or an int in [-128, 127] or [0, 255]. */
+#define Py_CHARMASK(c)		((unsigned char)((c) & 0xff))
+
+#include "pyfpe.h"
+
+/* These definitions must match corresponding definitions in graminit.h.
+   There's code in compile.c that checks that they are the same. */
+#define Py_single_input 256
+#define Py_file_input 257
+#define Py_eval_input 258
+
+#ifdef HAVE_PTH
+/* GNU pth user-space thread support */
+#include <pth.h>
+#endif
+
+/* Define macros for inline documentation. */
+#define PyDoc_VAR(name) static char name[]
+#define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
+#ifdef WITH_DOC_STRINGS
+#define PyDoc_STR(str) str
+#else
+#define PyDoc_STR(str) ""
+#endif
+
+#endif /* !Py_PYTHON_H */

python/include/asdl.h

@@ -0,0 +1,45 @@
+#ifndef Py_ASDL_H
+#define Py_ASDL_H
+
+typedef PyObject * identifier;
+typedef PyObject * string;
+typedef PyObject * object;
+
+#ifndef __cplusplus
+typedef enum {false, true} bool;
+#endif
+
+/* It would be nice if the code generated by asdl_c.py was completely
+   independent of Python, but it is a goal the requires too much work
+   at this stage.  So, for example, I'll represent identifiers as
+   interned Python strings.
+*/
+
+/* XXX A sequence should be typed so that its use can be typechecked. */
+
+typedef struct {
+    int size;
+    void *elements[1];
+} asdl_seq;
+
+typedef struct {
+    int size;
+    int elements[1];
+} asdl_int_seq;
+
+asdl_seq *asdl_seq_new(int size, PyArena *arena);
+asdl_int_seq *asdl_int_seq_new(int size, PyArena *arena);
+
+#define asdl_seq_GET(S, I) (S)->elements[(I)]
+#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size)
+#ifdef Py_DEBUG
+#define asdl_seq_SET(S, I, V) { \
+        int _asdl_i = (I); \
+        assert((S) && _asdl_i < (S)->size); \
+        (S)->elements[_asdl_i] = (V); \
+}
+#else
+#define asdl_seq_SET(S, I, V) (S)->elements[I] = (V)
+#endif
+
+#endif /* !Py_ASDL_H */

python/include/ast.h

@@ -0,0 +1,13 @@
+#ifndef Py_AST_H
+#define Py_AST_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(mod_ty) PyAST_FromNode(const node *, PyCompilerFlags *flags,
+				  const char *, PyArena *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_AST_H */

python/include/bitset.h

@@ -0,0 +1,32 @@
+
+#ifndef Py_BITSET_H
+#define Py_BITSET_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Bitset interface */
+
+#define BYTE		char
+
+typedef BYTE *bitset;
+
+bitset newbitset(int nbits);
+void delbitset(bitset bs);
+#define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0)
+int addbit(bitset bs, int ibit); /* Returns 0 if already set */
+int samebitset(bitset bs1, bitset bs2, int nbits);
+void mergebitset(bitset bs1, bitset bs2, int nbits);
+
+#define BITSPERBYTE	(8*sizeof(BYTE))
+#define NBYTES(nbits)	(((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
+
+#define BIT2BYTE(ibit)	((ibit) / BITSPERBYTE)
+#define BIT2SHIFT(ibit)	((ibit) % BITSPERBYTE)
+#define BIT2MASK(ibit)	(1 << BIT2SHIFT(ibit))
+#define BYTE2BIT(ibyte)	((ibyte) * BITSPERBYTE)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BITSET_H */

python/include/boolobject.h

@@ -0,0 +1,36 @@
+/* Boolean object interface */
+
+#ifndef Py_BOOLOBJECT_H
+#define Py_BOOLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+typedef PyIntObject PyBoolObject;
+
+PyAPI_DATA(PyTypeObject) PyBool_Type;
+
+#define PyBool_Check(x) (Py_TYPE(x) == &PyBool_Type)
+
+/* Py_False and Py_True are the only two bools in existence.
+Don't forget to apply Py_INCREF() when returning either!!! */
+
+/* Don't use these directly */
+PyAPI_DATA(PyIntObject) _Py_ZeroStruct, _Py_TrueStruct;
+
+/* Use these macros */
+#define Py_False ((PyObject *) &_Py_ZeroStruct)
+#define Py_True ((PyObject *) &_Py_TrueStruct)
+
+/* Macros for returning Py_True or Py_False, respectively */
+#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True
+#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False
+
+/* Function to return a bool from a C long */
+PyAPI_FUNC(PyObject *) PyBool_FromLong(long);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BOOLOBJECT_H */

python/include/bufferobject.h

@@ -0,0 +1,33 @@
+
+/* Buffer object interface */
+
+/* Note: the object's structure is private */
+
+#ifndef Py_BUFFEROBJECT_H
+#define Py_BUFFEROBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+PyAPI_DATA(PyTypeObject) PyBuffer_Type;
+
+#define PyBuffer_Check(op) (Py_TYPE(op) == &PyBuffer_Type)
+
+#define Py_END_OF_BUFFER	(-1)
+
+PyAPI_FUNC(PyObject *) PyBuffer_FromObject(PyObject *base,
+                                           Py_ssize_t offset, Py_ssize_t size);
+PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteObject(PyObject *base,
+                                                    Py_ssize_t offset,
+                                                    Py_ssize_t size);
+
+PyAPI_FUNC(PyObject *) PyBuffer_FromMemory(void *ptr, Py_ssize_t size);
+PyAPI_FUNC(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size);
+
+PyAPI_FUNC(PyObject *) PyBuffer_New(Py_ssize_t size);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BUFFEROBJECT_H */

python/include/bytearrayobject.h

@@ -0,0 +1,57 @@
+/* ByteArray object interface */
+
+#ifndef Py_BYTEARRAYOBJECT_H
+#define Py_BYTEARRAYOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdarg.h>
+
+/* Type PyByteArrayObject represents a mutable array of bytes.
+ * The Python API is that of a sequence;
+ * the bytes are mapped to ints in [0, 256).
+ * Bytes are not characters; they may be used to encode characters.
+ * The only way to go between bytes and str/unicode is via encoding
+ * and decoding.
+ * For the convenience of C programmers, the bytes type is considered
+ * to contain a char pointer, not an unsigned char pointer.
+ */
+
+/* Object layout */
+typedef struct {
+    PyObject_VAR_HEAD
+    /* XXX(nnorwitz): should ob_exports be Py_ssize_t? */
+    int ob_exports; /* how many buffer exports */
+    Py_ssize_t ob_alloc; /* How many bytes allocated */
+    char *ob_bytes;
+} PyByteArrayObject;
+
+/* Type object */
+PyAPI_DATA(PyTypeObject) PyByteArray_Type;
+PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type;
+
+/* Type check macros */
+#define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type)
+#define PyByteArray_CheckExact(self) (Py_TYPE(self) == &PyByteArray_Type)
+
+/* Direct API functions */
+PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *);
+PyAPI_FUNC(PyObject *) PyByteArray_Concat(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyByteArray_FromStringAndSize(const char *, Py_ssize_t);
+PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *);
+PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *);
+PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t);
+
+/* Macros, trading safety for speed */
+#define PyByteArray_AS_STRING(self) \
+    (assert(PyByteArray_Check(self)), \
+     Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_bytes : _PyByteArray_empty_string)
+#define PyByteArray_GET_SIZE(self)  (assert(PyByteArray_Check(self)),Py_SIZE(self))
+
+PyAPI_DATA(char) _PyByteArray_empty_string[];
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_BYTEARRAYOBJECT_H */

python/include/bytes_methods.h

@@ -0,0 +1,75 @@
+#ifndef Py_BYTES_CTYPE_H
+#define Py_BYTES_CTYPE_H
+
+/*
+ * The internal implementation behind PyString (bytes) and PyBytes (buffer)
+ * methods of the given names, they operate on ASCII byte strings.
+ */
+extern PyObject* _Py_bytes_isspace(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isalpha(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isalnum(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isdigit(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_islower(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_isupper(const char *cptr, Py_ssize_t len);
+extern PyObject* _Py_bytes_istitle(const char *cptr, Py_ssize_t len);
+
+/* These store their len sized answer in the given preallocated *result arg. */
+extern void _Py_bytes_lower(char *result, const char *cptr, Py_ssize_t len);
+extern void _Py_bytes_upper(char *result, const char *cptr, Py_ssize_t len);
+extern void _Py_bytes_title(char *result, char *s, Py_ssize_t len);
+extern void _Py_bytes_capitalize(char *result, char *s, Py_ssize_t len);
+extern void _Py_bytes_swapcase(char *result, char *s, Py_ssize_t len);
+
+/* Shared __doc__ strings. */
+extern const char _Py_isspace__doc__[];
+extern const char _Py_isalpha__doc__[];
+extern const char _Py_isalnum__doc__[];
+extern const char _Py_isdigit__doc__[];
+extern const char _Py_islower__doc__[];
+extern const char _Py_isupper__doc__[];
+extern const char _Py_istitle__doc__[];
+extern const char _Py_lower__doc__[];
+extern const char _Py_upper__doc__[];
+extern const char _Py_title__doc__[];
+extern const char _Py_capitalize__doc__[];
+extern const char _Py_swapcase__doc__[];
+
+/* These are left in for backward compatibility and will be removed
+   in 2.8/3.2 */
+#define ISLOWER(c)  Py_ISLOWER(c)
+#define ISUPPER(c)  Py_ISUPPER(c)
+#define ISALPHA(c)  Py_ISALPHA(c)
+#define ISDIGIT(c)  Py_ISDIGIT(c)
+#define ISXDIGIT(c) Py_ISXDIGIT(c)
+#define ISALNUM(c)  Py_ISALNUM(c)
+#define ISSPACE(c)  Py_ISSPACE(c)
+
+#undef islower
+#define islower(c) undefined_islower(c)
+#undef isupper
+#define isupper(c) undefined_isupper(c)
+#undef isalpha
+#define isalpha(c) undefined_isalpha(c)
+#undef isdigit
+#define isdigit(c) undefined_isdigit(c)
+#undef isxdigit
+#define isxdigit(c) undefined_isxdigit(c)
+#undef isalnum
+#define isalnum(c) undefined_isalnum(c)
+#undef isspace
+#define isspace(c) undefined_isspace(c)
+
+/* These are left in for backward compatibility and will be removed
+   in 2.8/3.2 */
+#define TOLOWER(c) Py_TOLOWER(c)
+#define TOUPPER(c) Py_TOUPPER(c)
+
+#undef tolower
+#define tolower(c) undefined_tolower(c)
+#undef toupper
+#define toupper(c) undefined_toupper(c)
+
+/* this is needed because some docs are shared from the .o, not static */
+#define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str)
+
+#endif /* !Py_BYTES_CTYPE_H */

python/include/bytesobject.h

@@ -0,0 +1,27 @@
+#define PyBytesObject PyStringObject
+#define PyBytes_Type PyString_Type
+
+#define PyBytes_Check PyString_Check
+#define PyBytes_CheckExact PyString_CheckExact 
+#define PyBytes_CHECK_INTERNED PyString_CHECK_INTERNED
+#define PyBytes_AS_STRING PyString_AS_STRING
+#define PyBytes_GET_SIZE PyString_GET_SIZE
+#define Py_TPFLAGS_BYTES_SUBCLASS Py_TPFLAGS_STRING_SUBCLASS
+
+#define PyBytes_FromStringAndSize PyString_FromStringAndSize
+#define PyBytes_FromString PyString_FromString
+#define PyBytes_FromFormatV PyString_FromFormatV
+#define PyBytes_FromFormat PyString_FromFormat
+#define PyBytes_Size PyString_Size
+#define PyBytes_AsString PyString_AsString
+#define PyBytes_Repr PyString_Repr
+#define PyBytes_Concat PyString_Concat
+#define PyBytes_ConcatAndDel PyString_ConcatAndDel
+#define _PyBytes_Resize _PyString_Resize
+#define _PyBytes_Eq _PyString_Eq
+#define PyBytes_Format PyString_Format
+#define _PyBytes_FormatLong _PyString_FormatLong
+#define PyBytes_DecodeEscape PyString_DecodeEscape
+#define _PyBytes_Join _PyString_Join
+#define PyBytes_AsStringAndSize PyString_AsStringAndSize
+#define _PyBytes_InsertThousandsGrouping _PyString_InsertThousandsGrouping

python/include/cStringIO.h

@@ -0,0 +1,73 @@
+#ifndef Py_CSTRINGIO_H
+#define Py_CSTRINGIO_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+
+  This header provides access to cStringIO objects from C.
+  Functions are provided for calling cStringIO objects and
+  macros are provided for testing whether you have cStringIO 
+  objects.
+
+  Before calling any of the functions or macros, you must initialize
+  the routines with:
+
+    PycString_IMPORT
+
+  This would typically be done in your init function.
+
+*/
+
+#define PycStringIO_CAPSULE_NAME "cStringIO.cStringIO_CAPI"
+
+#define PycString_IMPORT \
+  PycStringIO = ((struct PycStringIO_CAPI*)PyCapsule_Import(\
+    PycStringIO_CAPSULE_NAME, 0))
+
+/* Basic functions to manipulate cStringIO objects from C */
+
+static struct PycStringIO_CAPI {
+  
+ /* Read a string from an input object.  If the last argument
+    is -1, the remainder will be read.
+    */
+  int(*cread)(PyObject *, char **, Py_ssize_t);
+
+ /* Read a line from an input object.  Returns the length of the read
+    line as an int and a pointer inside the object buffer as char** (so
+    the caller doesn't have to provide its own buffer as destination).
+    */
+  int(*creadline)(PyObject *, char **);
+
+  /* Write a string to an output object*/
+  int(*cwrite)(PyObject *, const char *, Py_ssize_t);
+
+  /* Get the output object as a Python string (returns new reference). */
+  PyObject *(*cgetvalue)(PyObject *);
+
+  /* Create a new output object */
+  PyObject *(*NewOutput)(int);
+
+  /* Create an input object from a Python string
+     (copies the Python string reference).
+     */
+  PyObject *(*NewInput)(PyObject *);
+
+  /* The Python types for cStringIO input and output objects.
+     Note that you can do input on an output object.
+     */
+  PyTypeObject *InputType, *OutputType;
+
+} *PycStringIO;
+
+/* These can be used to test if you have one */
+#define PycStringIO_InputCheck(O) \
+  (Py_TYPE(O)==PycStringIO->InputType)
+#define PycStringIO_OutputCheck(O) \
+  (Py_TYPE(O)==PycStringIO->OutputType)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CSTRINGIO_H */

python/include/cellobject.h

@@ -0,0 +1,28 @@
+/* Cell object interface */
+
+#ifndef Py_CELLOBJECT_H
+#define Py_CELLOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	PyObject_HEAD
+	PyObject *ob_ref;	/* Content of the cell or NULL when empty */
+} PyCellObject;
+
+PyAPI_DATA(PyTypeObject) PyCell_Type;
+
+#define PyCell_Check(op) (Py_TYPE(op) == &PyCell_Type)
+
+PyAPI_FUNC(PyObject *) PyCell_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *);
+PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *);
+
+#define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref)
+#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v)
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_TUPLEOBJECT_H */

python/include/ceval.h

@@ -0,0 +1,153 @@
+#ifndef Py_CEVAL_H
+#define Py_CEVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Interface to random parts in ceval.c */
+
+PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords(
+    PyObject *, PyObject *, PyObject *);
+
+/* Inline this */
+#define PyEval_CallObject(func,arg) \
+    PyEval_CallObjectWithKeywords(func, arg, (PyObject *)NULL)
+
+PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *obj,
+                                           const char *format, ...);
+PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj,
+                                         const char *methodname,
+                                         const char *format, ...);
+
+PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *);
+PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *);
+
+struct _frame; /* Avoid including frameobject.h */
+
+PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void);
+PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
+PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
+PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void);
+PyAPI_FUNC(int) PyEval_GetRestricted(void);
+
+/* Look at the current frame's (if any) code's co_flags, and turn on
+   the corresponding compiler flags in cf->cf_flags.  Return 1 if any
+   flag was set, else return 0. */
+PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
+
+PyAPI_FUNC(int) Py_FlushLine(void);
+
+PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
+PyAPI_FUNC(int) Py_MakePendingCalls(void);
+
+/* Protection against deeply nested recursive calls */
+PyAPI_FUNC(void) Py_SetRecursionLimit(int);
+PyAPI_FUNC(int) Py_GetRecursionLimit(void);
+
+#define Py_EnterRecursiveCall(where)                                    \
+            (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) &&  \
+             _Py_CheckRecursiveCall(where))
+#define Py_LeaveRecursiveCall()                         \
+            (--PyThreadState_GET()->recursion_depth)
+PyAPI_FUNC(int) _Py_CheckRecursiveCall(char *where);
+PyAPI_DATA(int) _Py_CheckRecursionLimit;
+#ifdef USE_STACKCHECK
+#  define _Py_MakeRecCheck(x)  (++(x) > --_Py_CheckRecursionLimit)
+#else
+#  define _Py_MakeRecCheck(x)  (++(x) > _Py_CheckRecursionLimit)
+#endif
+
+PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *);
+PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_GetCallStats(PyObject *);
+PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *);
+PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc);
+
+/* this used to be handled on a per-thread basis - now just two globals */
+PyAPI_DATA(volatile int) _Py_Ticker;
+PyAPI_DATA(int) _Py_CheckInterval;
+
+/* Interface for threads.
+
+   A module that plans to do a blocking system call (or something else
+   that lasts a long time and doesn't touch Python data) can allow other
+   threads to run as follows:
+
+    ...preparations here...
+    Py_BEGIN_ALLOW_THREADS
+    ...blocking system call here...
+    Py_END_ALLOW_THREADS
+    ...interpret result here...
+
+   The Py_BEGIN_ALLOW_THREADS/Py_END_ALLOW_THREADS pair expands to a
+   {}-surrounded block.
+   To leave the block in the middle (e.g., with return), you must insert
+   a line containing Py_BLOCK_THREADS before the return, e.g.
+
+    if (...premature_exit...) {
+        Py_BLOCK_THREADS
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+
+   An alternative is:
+
+    Py_BLOCK_THREADS
+    if (...premature_exit...) {
+        PyErr_SetFromErrno(PyExc_IOError);
+        return NULL;
+    }
+    Py_UNBLOCK_THREADS
+
+   For convenience, that the value of 'errno' is restored across
+   Py_END_ALLOW_THREADS and Py_BLOCK_THREADS.
+
+   WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND
+   Py_END_ALLOW_THREADS!!!
+
+   The function PyEval_InitThreads() should be called only from
+   initthread() in "threadmodule.c".
+
+   Note that not yet all candidates have been converted to use this
+   mechanism!
+*/
+
+PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void);
+PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *);
+
+#ifdef WITH_THREAD
+
+PyAPI_FUNC(int)  PyEval_ThreadsInitialized(void);
+PyAPI_FUNC(void) PyEval_InitThreads(void);
+PyAPI_FUNC(void) PyEval_AcquireLock(void);
+PyAPI_FUNC(void) PyEval_ReleaseLock(void);
+PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate);
+PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate);
+PyAPI_FUNC(void) PyEval_ReInitThreads(void);
+
+#define Py_BEGIN_ALLOW_THREADS { \
+                        PyThreadState *_save; \
+                        _save = PyEval_SaveThread();
+#define Py_BLOCK_THREADS        PyEval_RestoreThread(_save);
+#define Py_UNBLOCK_THREADS      _save = PyEval_SaveThread();
+#define Py_END_ALLOW_THREADS    PyEval_RestoreThread(_save); \
+                 }
+
+#else /* !WITH_THREAD */
+
+#define Py_BEGIN_ALLOW_THREADS {
+#define Py_BLOCK_THREADS
+#define Py_UNBLOCK_THREADS
+#define Py_END_ALLOW_THREADS }
+
+#endif /* !WITH_THREAD */
+
+PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CEVAL_H */

python/include/classobject.h

@@ -0,0 +1,83 @@
+
+/* Class object interface */
+
+/* Revealing some structures (not for general use) */
+
+#ifndef Py_CLASSOBJECT_H
+#define Py_CLASSOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    PyObject	*cl_bases;	/* A tuple of class objects */
+    PyObject	*cl_dict;	/* A dictionary */
+    PyObject	*cl_name;	/* A string */
+    /* The following three are functions or NULL */
+    PyObject	*cl_getattr;
+    PyObject	*cl_setattr;
+    PyObject	*cl_delattr;
+    PyObject    *cl_weakreflist; /* List of weak references */
+} PyClassObject;
+
+typedef struct {
+    PyObject_HEAD
+    PyClassObject *in_class;	/* The class object */
+    PyObject	  *in_dict;	/* A dictionary */
+    PyObject	  *in_weakreflist; /* List of weak references */
+} PyInstanceObject;
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *im_func;   /* The callable object implementing the method */
+    PyObject *im_self;   /* The instance it is bound to, or NULL */
+    PyObject *im_class;  /* The class that asked for the method */
+    PyObject *im_weakreflist; /* List of weak references */
+} PyMethodObject;
+
+PyAPI_DATA(PyTypeObject) PyClass_Type, PyInstance_Type, PyMethod_Type;
+
+#define PyClass_Check(op) ((op)->ob_type == &PyClass_Type)
+#define PyInstance_Check(op) ((op)->ob_type == &PyInstance_Type)
+#define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type)
+
+PyAPI_FUNC(PyObject *) PyClass_New(PyObject *, PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyInstance_New(PyObject *, PyObject *,
+                                            PyObject *);
+PyAPI_FUNC(PyObject *) PyInstance_NewRaw(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyMethod_New(PyObject *, PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyMethod_Function(PyObject *);
+PyAPI_FUNC(PyObject *) PyMethod_Self(PyObject *);
+PyAPI_FUNC(PyObject *) PyMethod_Class(PyObject *);
+
+/* Look up attribute with name (a string) on instance object pinst, using
+ * only the instance and base class dicts.  If a descriptor is found in
+ * a class dict, the descriptor is returned without calling it.
+ * Returns NULL if nothing found, else a borrowed reference to the
+ * value associated with name in the dict in which name was found.
+ * The point of this routine is that it never calls arbitrary Python
+ * code, so is always "safe":  all it does is dict lookups.  The function
+ * can't fail, never sets an exception, and NULL is not an error (it just
+ * means "not found").
+ */
+PyAPI_FUNC(PyObject *) _PyInstance_Lookup(PyObject *pinst, PyObject *name);
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyMethod_GET_FUNCTION(meth) \
+        (((PyMethodObject *)meth) -> im_func)
+#define PyMethod_GET_SELF(meth) \
+	(((PyMethodObject *)meth) -> im_self)
+#define PyMethod_GET_CLASS(meth) \
+	(((PyMethodObject *)meth) -> im_class)
+
+PyAPI_FUNC(int) PyClass_IsSubclass(PyObject *, PyObject *);
+
+PyAPI_FUNC(int) PyMethod_ClearFreeList(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CLASSOBJECT_H */

python/include/cobject.h

@@ -0,0 +1,89 @@
+/*
+   CObjects are marked Pending Deprecation as of Python 2.7.
+   The full schedule for 2.x is as follows:
+     - CObjects are marked Pending Deprecation in Python 2.7.
+     - CObjects will be marked Deprecated in Python 2.8
+       (if there is one).
+     - CObjects will be removed in Python 2.9 (if there is one).
+
+   Additionally, for the Python 3.x series:
+     - CObjects were marked Deprecated in Python 3.1.
+     - CObjects will be removed in Python 3.2.
+
+   You should switch all use of CObjects to capsules.  Capsules
+   have a safer and more consistent API.  For more information,
+   see Include/pycapsule.h, or read the "Capsules" topic in
+   the "Python/C API Reference Manual".
+
+   Python 2.7 no longer uses CObjects itself; all objects which
+   were formerly CObjects are now capsules.  Note that this change
+   does not by itself break binary compatibility with extensions
+   built for previous versions of Python--PyCObject_AsVoidPtr()
+   has been changed to also understand capsules.
+
+*/
+
+/* original file header comment follows: */
+
+/* C objects to be exported from one extension module to another.
+ 
+   C objects are used for communication between extension modules.
+   They provide a way for an extension module to export a C interface
+   to other extension modules, so that extension modules can use the
+   Python import mechanism to link to one another.
+
+*/
+
+#ifndef Py_COBJECT_H
+#define Py_COBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyCObject_Type;
+
+#define PyCObject_Check(op) (Py_TYPE(op) == &PyCObject_Type)
+
+/* Create a PyCObject from a pointer to a C object and an optional
+   destructor function.  If the second argument is non-null, then it
+   will be called with the first argument if and when the PyCObject is
+   destroyed.
+
+*/
+PyAPI_FUNC(PyObject *) PyCObject_FromVoidPtr(
+	void *cobj, void (*destruct)(void*));
+
+
+/* Create a PyCObject from a pointer to a C object, a description object,
+   and an optional destructor function.  If the third argument is non-null,
+   then it will be called with the first and second arguments if and when 
+   the PyCObject is destroyed.
+*/
+PyAPI_FUNC(PyObject *) PyCObject_FromVoidPtrAndDesc(
+	void *cobj, void *desc, void (*destruct)(void*,void*));
+
+/* Retrieve a pointer to a C object from a PyCObject. */
+PyAPI_FUNC(void *) PyCObject_AsVoidPtr(PyObject *);
+
+/* Retrieve a pointer to a description object from a PyCObject. */
+PyAPI_FUNC(void *) PyCObject_GetDesc(PyObject *);
+
+/* Import a pointer to a C object from a module using a PyCObject. */
+PyAPI_FUNC(void *) PyCObject_Import(char *module_name, char *cobject_name);
+
+/* Modify a C object. Fails (==0) if object has a destructor. */
+PyAPI_FUNC(int) PyCObject_SetVoidPtr(PyObject *self, void *cobj);
+
+
+typedef struct {
+    PyObject_HEAD
+    void *cobject;
+    void *desc;
+    void (*destructor)(void *);
+} PyCObject;
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_COBJECT_H */

python/include/code.h

@@ -0,0 +1,107 @@
+/* Definitions for bytecode */
+
+#ifndef Py_CODE_H
+#define Py_CODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Bytecode object */
+typedef struct {
+    PyObject_HEAD
+    int co_argcount;		/* #arguments, except *args */
+    int co_nlocals;		/* #local variables */
+    int co_stacksize;		/* #entries needed for evaluation stack */
+    int co_flags;		/* CO_..., see below */
+    PyObject *co_code;		/* instruction opcodes */
+    PyObject *co_consts;	/* list (constants used) */
+    PyObject *co_names;		/* list of strings (names used) */
+    PyObject *co_varnames;	/* tuple of strings (local variable names) */
+    PyObject *co_freevars;	/* tuple of strings (free variable names) */
+    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */
+    /* The rest doesn't count for hash/cmp */
+    PyObject *co_filename;	/* string (where it was loaded from) */
+    PyObject *co_name;		/* string (name, for reference) */
+    int co_firstlineno;		/* first source line number */
+    PyObject *co_lnotab;	/* string (encoding addr<->lineno mapping) See
+				   Objects/lnotab_notes.txt for details. */
+    void *co_zombieframe;     /* for optimization only (see frameobject.c) */
+    PyObject *co_weakreflist;   /* to support weakrefs to code objects */
+} PyCodeObject;
+
+/* Masks for co_flags above */
+#define CO_OPTIMIZED	0x0001
+#define CO_NEWLOCALS	0x0002
+#define CO_VARARGS	0x0004
+#define CO_VARKEYWORDS	0x0008
+#define CO_NESTED       0x0010
+#define CO_GENERATOR    0x0020
+/* The CO_NOFREE flag is set if there are no free or cell variables.
+   This information is redundant, but it allows a single flag test
+   to determine whether there is any extra work to be done when the
+   call frame it setup.
+*/
+#define CO_NOFREE       0x0040
+
+#if 0
+/* This is no longer used.  Stopped defining in 2.5, do not re-use. */
+#define CO_GENERATOR_ALLOWED    0x1000
+#endif
+#define CO_FUTURE_DIVISION    	0x2000
+#define CO_FUTURE_ABSOLUTE_IMPORT 0x4000 /* do absolute imports by default */
+#define CO_FUTURE_WITH_STATEMENT  0x8000
+#define CO_FUTURE_PRINT_FUNCTION  0x10000
+#define CO_FUTURE_UNICODE_LITERALS 0x20000
+
+/* This should be defined if a future statement modifies the syntax.
+   For example, when a keyword is added.
+*/
+#if 1
+#define PY_PARSER_REQUIRES_FUTURE_KEYWORD
+#endif
+
+#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */
+
+PyAPI_DATA(PyTypeObject) PyCode_Type;
+
+#define PyCode_Check(op) (Py_TYPE(op) == &PyCode_Type)
+#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars))
+
+/* Public interface */
+PyAPI_FUNC(PyCodeObject *) PyCode_New(
+	int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
+	PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *); 
+        /* same as struct above */
+
+/* Creates a new empty code object with the specified source location. */
+PyAPI_FUNC(PyCodeObject *)
+PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno);
+
+/* Return the line number associated with the specified bytecode index
+   in this code object.  If you just need the line number of a frame,
+   use PyFrame_GetLineNumber() instead. */
+PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int);
+
+/* for internal use only */
+#define _PyCode_GETCODEPTR(co, pp) \
+	((*Py_TYPE((co)->co_code)->tp_as_buffer->bf_getreadbuffer) \
+	 ((co)->co_code, 0, (void **)(pp)))
+
+typedef struct _addr_pair {
+        int ap_lower;
+        int ap_upper;
+} PyAddrPair;
+
+/* Update *bounds to describe the first and one-past-the-last instructions in the
+   same line as lasti.  Return the number of that line.
+*/
+PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co,
+                                        int lasti, PyAddrPair *bounds);
+
+PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts,
+                                      PyObject *names, PyObject *lineno_obj);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CODE_H */

python/include/codecs.h

@@ -0,0 +1,167 @@
+#ifndef Py_CODECREGISTRY_H
+#define Py_CODECREGISTRY_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ------------------------------------------------------------------------
+
+   Python Codec Registry and support functions
+
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+Copyright (c) Corporation for National Research Initiatives.
+
+   ------------------------------------------------------------------------ */
+
+/* Register a new codec search function.
+
+   As side effect, this tries to load the encodings package, if not
+   yet done, to make sure that it is always first in the list of
+   search functions.
+
+   The search_function's refcount is incremented by this function. */
+
+PyAPI_FUNC(int) PyCodec_Register(
+       PyObject *search_function
+       );
+
+/* Codec register lookup API.
+
+   Looks up the given encoding and returns a CodecInfo object with
+   function attributes which implement the different aspects of
+   processing the encoding.
+
+   The encoding string is looked up converted to all lower-case
+   characters. This makes encodings looked up through this mechanism
+   effectively case-insensitive.
+
+   If no codec is found, a KeyError is set and NULL returned.
+
+   As side effect, this tries to load the encodings package, if not
+   yet done. This is part of the lazy load strategy for the encodings
+   package.
+
+ */
+
+PyAPI_FUNC(PyObject *) _PyCodec_Lookup(
+       const char *encoding
+       );
+
+/* Generic codec based encoding API.
+
+   object is passed through the encoder function found for the given
+   encoding using the error handling method defined by errors. errors
+   may be NULL to use the default method defined for the codec.
+   
+   Raises a LookupError in case no encoder can be found.
+
+ */
+
+PyAPI_FUNC(PyObject *) PyCodec_Encode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+/* Generic codec based decoding API.
+
+   object is passed through the decoder function found for the given
+   encoding using the error handling method defined by errors. errors
+   may be NULL to use the default method defined for the codec.
+   
+   Raises a LookupError in case no encoder can be found.
+
+ */
+
+PyAPI_FUNC(PyObject *) PyCodec_Decode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+
+/* --- Codec Lookup APIs -------------------------------------------------- 
+
+   All APIs return a codec object with incremented refcount and are
+   based on _PyCodec_Lookup().  The same comments w/r to the encoding
+   name also apply to these APIs.
+
+*/
+
+/* Get an encoder function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_Encoder(
+       const char *encoding
+       );
+
+/* Get a decoder function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_Decoder(
+       const char *encoding
+       );
+
+/* Get a IncrementalEncoder object for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_IncrementalEncoder(
+       const char *encoding,
+       const char *errors
+       );
+
+/* Get a IncrementalDecoder object function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_IncrementalDecoder(
+       const char *encoding,
+       const char *errors
+       );
+
+/* Get a StreamReader factory function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_StreamReader(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+
+/* Get a StreamWriter factory function for the given encoding. */
+
+PyAPI_FUNC(PyObject *) PyCodec_StreamWriter(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+
+/* Unicode encoding error handling callback registry API */
+
+/* Register the error handling callback function error under the given
+   name. This function will be called by the codec when it encounters
+   unencodable characters/undecodable bytes and doesn't know the
+   callback name, when name is specified as the error parameter
+   in the call to the encode/decode function.
+   Return 0 on success, -1 on error */
+PyAPI_FUNC(int) PyCodec_RegisterError(const char *name, PyObject *error);
+
+/* Lookup the error handling callback function registered under the given
+   name. As a special case NULL can be passed, in which case
+   the error handling callback for "strict" will be returned. */
+PyAPI_FUNC(PyObject *) PyCodec_LookupError(const char *name);
+
+/* raise exc as an exception */
+PyAPI_FUNC(PyObject *) PyCodec_StrictErrors(PyObject *exc);
+
+/* ignore the unicode error, skipping the faulty input */
+PyAPI_FUNC(PyObject *) PyCodec_IgnoreErrors(PyObject *exc);
+
+/* replace the unicode encode error with ? or U+FFFD */
+PyAPI_FUNC(PyObject *) PyCodec_ReplaceErrors(PyObject *exc);
+
+/* replace the unicode encode error with XML character references */
+PyAPI_FUNC(PyObject *) PyCodec_XMLCharRefReplaceErrors(PyObject *exc);
+
+/* replace the unicode encode error with backslash escapes (\x, \u and \U) */
+PyAPI_FUNC(PyObject *) PyCodec_BackslashReplaceErrors(PyObject *exc);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_CODECREGISTRY_H */

python/include/compile.h

@@ -0,0 +1,40 @@
+
+#ifndef Py_COMPILE_H
+#define Py_COMPILE_H
+
+#include "code.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Public interface */
+struct _node; /* Declare the existence of this type */
+PyAPI_FUNC(PyCodeObject *) PyNode_Compile(struct _node *, const char *);
+
+/* Future feature support */
+
+typedef struct {
+    int ff_features;      /* flags set by future statements */
+    int ff_lineno;        /* line number of last future statement */
+} PyFutureFeatures;
+
+#define FUTURE_NESTED_SCOPES "nested_scopes"
+#define FUTURE_GENERATORS "generators"
+#define FUTURE_DIVISION "division"
+#define FUTURE_ABSOLUTE_IMPORT "absolute_import"
+#define FUTURE_WITH_STATEMENT "with_statement"
+#define FUTURE_PRINT_FUNCTION "print_function"
+#define FUTURE_UNICODE_LITERALS "unicode_literals"
+
+
+struct _mod; /* Declare the existence of this type */
+PyAPI_FUNC(PyCodeObject *) PyAST_Compile(struct _mod *, const char *,
+					PyCompilerFlags *, PyArena *);
+PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST(struct _mod *, const char *);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_COMPILE_H */

python/include/complexobject.h

@@ -0,0 +1,66 @@
+/* Complex number structure */
+
+#ifndef Py_COMPLEXOBJECT_H
+#define Py_COMPLEXOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    double real;
+    double imag;
+} Py_complex;
+
+/* Operations on complex numbers from complexmodule.c */
+
+#define c_sum _Py_c_sum
+#define c_diff _Py_c_diff
+#define c_neg _Py_c_neg
+#define c_prod _Py_c_prod
+#define c_quot _Py_c_quot
+#define c_pow _Py_c_pow
+#define c_abs _Py_c_abs
+
+PyAPI_FUNC(Py_complex) c_sum(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) c_diff(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) c_neg(Py_complex);
+PyAPI_FUNC(Py_complex) c_prod(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) c_quot(Py_complex, Py_complex);
+PyAPI_FUNC(Py_complex) c_pow(Py_complex, Py_complex);
+PyAPI_FUNC(double) c_abs(Py_complex);
+
+
+/* Complex object interface */
+
+/*
+PyComplexObject represents a complex number with double-precision
+real and imaginary parts.
+*/
+
+typedef struct {
+    PyObject_HEAD
+    Py_complex cval;
+} PyComplexObject;     
+
+PyAPI_DATA(PyTypeObject) PyComplex_Type;
+
+#define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type)
+#define PyComplex_CheckExact(op) (Py_TYPE(op) == &PyComplex_Type)
+
+PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex);
+PyAPI_FUNC(PyObject *) PyComplex_FromDoubles(double real, double imag);
+
+PyAPI_FUNC(double) PyComplex_RealAsDouble(PyObject *op);
+PyAPI_FUNC(double) PyComplex_ImagAsDouble(PyObject *op);
+PyAPI_FUNC(Py_complex) PyComplex_AsCComplex(PyObject *op);
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(PyObject *) _PyComplex_FormatAdvanced(PyObject *obj,
+                                                 char *format_spec,
+                                                 Py_ssize_t format_spec_len);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_COMPLEXOBJECT_H */

python/include/datetime.h

@@ -0,0 +1,239 @@
+/*  datetime.h
+ */
+
+#ifndef DATETIME_H
+#define DATETIME_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Fields are packed into successive bytes, each viewed as unsigned and
+ * big-endian, unless otherwise noted:
+ *
+ * byte offset
+ *  0           year     2 bytes, 1-9999
+ *  2           month    1 byte, 1-12
+ *  3           day      1 byte, 1-31
+ *  4           hour     1 byte, 0-23
+ *  5           minute   1 byte, 0-59
+ *  6           second   1 byte, 0-59
+ *  7           usecond  3 bytes, 0-999999
+ * 10
+ */
+
+/* # of bytes for year, month, and day. */
+#define _PyDateTime_DATE_DATASIZE 4
+
+/* # of bytes for hour, minute, second, and usecond. */
+#define _PyDateTime_TIME_DATASIZE 6
+
+/* # of bytes for year, month, day, hour, minute, second, and usecond. */
+#define _PyDateTime_DATETIME_DATASIZE 10
+
+
+typedef struct
+{
+    PyObject_HEAD
+    long hashcode;              /* -1 when unknown */
+    int days;                   /* -MAX_DELTA_DAYS <= days <= MAX_DELTA_DAYS */
+    int seconds;                /* 0 <= seconds < 24*3600 is invariant */
+    int microseconds;           /* 0 <= microseconds < 1000000 is invariant */
+} PyDateTime_Delta;
+
+typedef struct
+{
+    PyObject_HEAD               /* a pure abstract base clase */
+} PyDateTime_TZInfo;
+
+
+/* The datetime and time types have hashcodes, and an optional tzinfo member,
+ * present if and only if hastzinfo is true.
+ */
+#define _PyTZINFO_HEAD          \
+    PyObject_HEAD               \
+    long hashcode;              \
+    char hastzinfo;             /* boolean flag */
+
+/* No _PyDateTime_BaseTZInfo is allocated; it's just to have something
+ * convenient to cast to, when getting at the hastzinfo member of objects
+ * starting with _PyTZINFO_HEAD.
+ */
+typedef struct
+{
+    _PyTZINFO_HEAD
+} _PyDateTime_BaseTZInfo;
+
+/* All time objects are of PyDateTime_TimeType, but that can be allocated
+ * in two ways, with or without a tzinfo member.  Without is the same as
+ * tzinfo == None, but consumes less memory.  _PyDateTime_BaseTime is an
+ * internal struct used to allocate the right amount of space for the
+ * "without" case.
+ */
+#define _PyDateTime_TIMEHEAD    \
+    _PyTZINFO_HEAD              \
+    unsigned char data[_PyDateTime_TIME_DATASIZE];
+
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+} _PyDateTime_BaseTime;         /* hastzinfo false */
+
+typedef struct
+{
+    _PyDateTime_TIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_Time;              /* hastzinfo true */
+
+
+/* All datetime objects are of PyDateTime_DateTimeType, but that can be
+ * allocated in two ways too, just like for time objects above.  In addition,
+ * the plain date type is a base class for datetime, so it must also have
+ * a hastzinfo member (although it's unused there).
+ */
+typedef struct
+{
+    _PyTZINFO_HEAD
+    unsigned char data[_PyDateTime_DATE_DATASIZE];
+} PyDateTime_Date;
+
+#define _PyDateTime_DATETIMEHEAD        \
+    _PyTZINFO_HEAD                      \
+    unsigned char data[_PyDateTime_DATETIME_DATASIZE];
+
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+} _PyDateTime_BaseDateTime;     /* hastzinfo false */
+
+typedef struct
+{
+    _PyDateTime_DATETIMEHEAD
+    PyObject *tzinfo;
+} PyDateTime_DateTime;          /* hastzinfo true */
+
+
+/* Apply for date and datetime instances. */
+#define PyDateTime_GET_YEAR(o)     ((((PyDateTime_Date*)o)->data[0] << 8) | \
+                     ((PyDateTime_Date*)o)->data[1])
+#define PyDateTime_GET_MONTH(o)    (((PyDateTime_Date*)o)->data[2])
+#define PyDateTime_GET_DAY(o)      (((PyDateTime_Date*)o)->data[3])
+
+#define PyDateTime_DATE_GET_HOUR(o)        (((PyDateTime_DateTime*)o)->data[4])
+#define PyDateTime_DATE_GET_MINUTE(o)      (((PyDateTime_DateTime*)o)->data[5])
+#define PyDateTime_DATE_GET_SECOND(o)      (((PyDateTime_DateTime*)o)->data[6])
+#define PyDateTime_DATE_GET_MICROSECOND(o)              \
+    ((((PyDateTime_DateTime*)o)->data[7] << 16) |       \
+     (((PyDateTime_DateTime*)o)->data[8] << 8)  |       \
+      ((PyDateTime_DateTime*)o)->data[9])
+
+/* Apply for time instances. */
+#define PyDateTime_TIME_GET_HOUR(o)        (((PyDateTime_Time*)o)->data[0])
+#define PyDateTime_TIME_GET_MINUTE(o)      (((PyDateTime_Time*)o)->data[1])
+#define PyDateTime_TIME_GET_SECOND(o)      (((PyDateTime_Time*)o)->data[2])
+#define PyDateTime_TIME_GET_MICROSECOND(o)              \
+    ((((PyDateTime_Time*)o)->data[3] << 16) |           \
+     (((PyDateTime_Time*)o)->data[4] << 8)  |           \
+      ((PyDateTime_Time*)o)->data[5])
+
+
+/* Define structure for C API. */
+typedef struct {
+    /* type objects */
+    PyTypeObject *DateType;
+    PyTypeObject *DateTimeType;
+    PyTypeObject *TimeType;
+    PyTypeObject *DeltaType;
+    PyTypeObject *TZInfoType;
+
+    /* constructors */
+    PyObject *(*Date_FromDate)(int, int, int, PyTypeObject*);
+    PyObject *(*DateTime_FromDateAndTime)(int, int, int, int, int, int, int,
+        PyObject*, PyTypeObject*);
+    PyObject *(*Time_FromTime)(int, int, int, int, PyObject*, PyTypeObject*);
+    PyObject *(*Delta_FromDelta)(int, int, int, int, PyTypeObject*);
+
+    /* constructors for the DB API */
+    PyObject *(*DateTime_FromTimestamp)(PyObject*, PyObject*, PyObject*);
+    PyObject *(*Date_FromTimestamp)(PyObject*, PyObject*);
+
+} PyDateTime_CAPI;
+
+#define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI"
+
+
+/* "magic" constant used to partially protect against developer mistakes. */
+#define DATETIME_API_MAGIC 0x414548d5
+
+#ifdef Py_BUILD_CORE
+
+/* Macros for type checking when building the Python core. */
+#define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType)
+#define PyDate_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateType)
+
+#define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType)
+#define PyDateTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateTimeType)
+
+#define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType)
+#define PyTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TimeType)
+
+#define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType)
+#define PyDelta_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DeltaType)
+
+#define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType)
+#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TZInfoType)
+
+#else
+
+/* Define global variable for the C API and a macro for setting it. */
+static PyDateTime_CAPI *PyDateTimeAPI = NULL;
+
+#define PyDateTime_IMPORT \
+    PyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import(PyDateTime_CAPSULE_NAME, 0)
+
+/* Macros for type checking when not building the Python core. */
+#define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType)
+#define PyDate_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateType)
+
+#define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType)
+#define PyDateTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateTimeType)
+
+#define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType)
+#define PyTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TimeType)
+
+#define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType)
+#define PyDelta_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DeltaType)
+
+#define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType)
+#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TZInfoType)
+
+/* Macros for accessing constructors in a simplified fashion. */
+#define PyDate_FromDate(year, month, day) \
+    PyDateTimeAPI->Date_FromDate(year, month, day, PyDateTimeAPI->DateType)
+
+#define PyDateTime_FromDateAndTime(year, month, day, hour, min, sec, usec) \
+    PyDateTimeAPI->DateTime_FromDateAndTime(year, month, day, hour, \
+        min, sec, usec, Py_None, PyDateTimeAPI->DateTimeType)
+
+#define PyTime_FromTime(hour, minute, second, usecond) \
+    PyDateTimeAPI->Time_FromTime(hour, minute, second, usecond, \
+        Py_None, PyDateTimeAPI->TimeType)
+
+#define PyDelta_FromDSU(days, seconds, useconds) \
+    PyDateTimeAPI->Delta_FromDelta(days, seconds, useconds, 1, \
+        PyDateTimeAPI->DeltaType)
+
+/* Macros supporting the DB API. */
+#define PyDateTime_FromTimestamp(args) \
+    PyDateTimeAPI->DateTime_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateTimeType), args, NULL)
+
+#define PyDate_FromTimestamp(args) \
+    PyDateTimeAPI->Date_FromTimestamp( \
+        (PyObject*) (PyDateTimeAPI->DateType), args)
+
+#endif  /* Py_BUILD_CORE */
+
+#ifdef __cplusplus
+}
+#endif
+#endif

python/include/descrobject.h

@@ -0,0 +1,94 @@
+/* Descriptors */
+#ifndef Py_DESCROBJECT_H
+#define Py_DESCROBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef PyObject *(*getter)(PyObject *, void *);
+typedef int (*setter)(PyObject *, PyObject *, void *);
+
+typedef struct PyGetSetDef {
+    char *name;
+    getter get;
+    setter set;
+    char *doc;
+    void *closure;
+} PyGetSetDef;
+
+typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
+                                 void *wrapped);
+
+typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
+                                      void *wrapped, PyObject *kwds);
+
+struct wrapperbase {
+    char *name;
+    int offset;
+    void *function;
+    wrapperfunc wrapper;
+    char *doc;
+    int flags;
+    PyObject *name_strobj;
+};
+
+/* Flags for above struct */
+#define PyWrapperFlag_KEYWORDS 1 /* wrapper function takes keyword args */
+
+/* Various kinds of descriptor objects */
+
+#define PyDescr_COMMON \
+    PyObject_HEAD \
+    PyTypeObject *d_type; \
+    PyObject *d_name
+
+typedef struct {
+    PyDescr_COMMON;
+} PyDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    PyMethodDef *d_method;
+} PyMethodDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    struct PyMemberDef *d_member;
+} PyMemberDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    PyGetSetDef *d_getset;
+} PyGetSetDescrObject;
+
+typedef struct {
+    PyDescr_COMMON;
+    struct wrapperbase *d_base;
+    void *d_wrapped; /* This can be any function pointer */
+} PyWrapperDescrObject;
+
+PyAPI_DATA(PyTypeObject) PyWrapperDescr_Type;
+PyAPI_DATA(PyTypeObject) PyDictProxy_Type;
+PyAPI_DATA(PyTypeObject) PyGetSetDescr_Type;
+PyAPI_DATA(PyTypeObject) PyMemberDescr_Type;
+
+PyAPI_FUNC(PyObject *) PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
+                                               struct PyMemberDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
+                                               struct PyGetSetDef *);
+PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
+                                                struct wrapperbase *, void *);
+#define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)
+
+PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyWrapper_New(PyObject *, PyObject *);
+
+
+PyAPI_DATA(PyTypeObject) PyProperty_Type;
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DESCROBJECT_H */
+

python/include/dictobject.h

@@ -0,0 +1,156 @@
+#ifndef Py_DICTOBJECT_H
+#define Py_DICTOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Dictionary object type -- mapping from hashable object to object */
+
+/* The distribution includes a separate file, Objects/dictnotes.txt,
+   describing explorations into dictionary design and optimization.
+   It covers typical dictionary use patterns, the parameters for
+   tuning dictionaries, and several ideas for possible optimizations.
+*/
+
+/*
+There are three kinds of slots in the table:
+
+1. Unused.  me_key == me_value == NULL
+   Does not hold an active (key, value) pair now and never did.  Unused can
+   transition to Active upon key insertion.  This is the only case in which
+   me_key is NULL, and is each slot's initial state.
+
+2. Active.  me_key != NULL and me_key != dummy and me_value != NULL
+   Holds an active (key, value) pair.  Active can transition to Dummy upon
+   key deletion.  This is the only case in which me_value != NULL.
+
+3. Dummy.  me_key == dummy and me_value == NULL
+   Previously held an active (key, value) pair, but that was deleted and an
+   active pair has not yet overwritten the slot.  Dummy can transition to
+   Active upon key insertion.  Dummy slots cannot be made Unused again
+   (cannot have me_key set to NULL), else the probe sequence in case of
+   collision would have no way to know they were once active.
+
+Note: .popitem() abuses the me_hash field of an Unused or Dummy slot to
+hold a search finger.  The me_hash field of Unused or Dummy slots has no
+meaning otherwise.
+*/
+
+/* PyDict_MINSIZE is the minimum size of a dictionary.  This many slots are
+ * allocated directly in the dict object (in the ma_smalltable member).
+ * It must be a power of 2, and at least 4.  8 allows dicts with no more
+ * than 5 active entries to live in ma_smalltable (and so avoid an
+ * additional malloc); instrumentation suggested this suffices for the
+ * majority of dicts (consisting mostly of usually-small instance dicts and
+ * usually-small dicts created to pass keyword arguments).
+ */
+#define PyDict_MINSIZE 8
+
+typedef struct {
+    /* Cached hash code of me_key.  Note that hash codes are C longs.
+     * We have to use Py_ssize_t instead because dict_popitem() abuses
+     * me_hash to hold a search finger.
+     */
+    Py_ssize_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value;
+} PyDictEntry;
+
+/*
+To ensure the lookup algorithm terminates, there must be at least one Unused
+slot (NULL key) in the table.
+The value ma_fill is the number of non-NULL keys (sum of Active and Dummy);
+ma_used is the number of non-NULL, non-dummy keys (== the number of non-NULL
+values == the number of Active items).
+To avoid slowing down lookups on a near-full table, we resize the table when
+it's two-thirds full.
+*/
+typedef struct _dictobject PyDictObject;
+struct _dictobject {
+    PyObject_HEAD
+    Py_ssize_t ma_fill;  /* # Active + # Dummy */
+    Py_ssize_t ma_used;  /* # Active */
+
+    /* The table contains ma_mask + 1 slots, and that's a power of 2.
+     * We store the mask instead of the size because the mask is more
+     * frequently needed.
+     */
+    Py_ssize_t ma_mask;
+
+    /* ma_table points to ma_smalltable for small tables, else to
+     * additional malloc'ed memory.  ma_table is never NULL!  This rule
+     * saves repeated runtime null-tests in the workhorse getitem and
+     * setitem calls.
+     */
+    PyDictEntry *ma_table;
+    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+    PyDictEntry ma_smalltable[PyDict_MINSIZE];
+};
+
+PyAPI_DATA(PyTypeObject) PyDict_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterKey_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterValue_Type;
+PyAPI_DATA(PyTypeObject) PyDictIterItem_Type;
+PyAPI_DATA(PyTypeObject) PyDictKeys_Type;
+PyAPI_DATA(PyTypeObject) PyDictItems_Type;
+PyAPI_DATA(PyTypeObject) PyDictValues_Type;
+
+#define PyDict_Check(op) \
+                 PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
+#define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type)
+#define PyDictKeys_Check(op) (Py_TYPE(op) == &PyDictKeys_Type)
+#define PyDictItems_Check(op) (Py_TYPE(op) == &PyDictItems_Type)
+#define PyDictValues_Check(op) (Py_TYPE(op) == &PyDictValues_Type)
+/* This excludes Values, since they are not sets. */
+# define PyDictViewSet_Check(op) \
+    (PyDictKeys_Check(op) || PyDictItems_Check(op))
+
+PyAPI_FUNC(PyObject *) PyDict_New(void);
+PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key);
+PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
+PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key);
+PyAPI_FUNC(void) PyDict_Clear(PyObject *mp);
+PyAPI_FUNC(int) PyDict_Next(
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+PyAPI_FUNC(int) _PyDict_Next(
+    PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp);
+PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
+PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
+PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
+PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, long hash);
+PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
+PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
+
+/* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */
+PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other);
+
+/* PyDict_Merge updates/merges from a mapping object (an object that
+   supports PyMapping_Keys() and PyObject_GetItem()).  If override is true,
+   the last occurrence of a key wins, else the first.  The Python
+   dict.update(other) is equivalent to PyDict_Merge(dict, other, 1).
+*/
+PyAPI_FUNC(int) PyDict_Merge(PyObject *mp,
+                                   PyObject *other,
+                                   int override);
+
+/* PyDict_MergeFromSeq2 updates/merges from an iterable object producing
+   iterable objects of length 2.  If override is true, the last occurrence
+   of a key wins, else the first.  The Python dict constructor dict(seq2)
+   is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1).
+*/
+PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d,
+                                           PyObject *seq2,
+                                           int override);
+
+PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key);
+PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
+PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_DICTOBJECT_H */

python/include/dtoa.h

@@ -0,0 +1,15 @@
+#ifndef PY_NO_SHORT_FLOAT_REPR
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(double) _Py_dg_strtod(const char *str, char **ptr);
+PyAPI_FUNC(char *) _Py_dg_dtoa(double d, int mode, int ndigits,
+                        int *decpt, int *sign, char **rve);
+PyAPI_FUNC(void) _Py_dg_freedtoa(char *s);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif

python/include/enumobject.h

@@ -0,0 +1,17 @@
+#ifndef Py_ENUMOBJECT_H
+#define Py_ENUMOBJECT_H
+
+/* Enumerate Object */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_DATA(PyTypeObject) PyEnum_Type;
+PyAPI_DATA(PyTypeObject) PyReversed_Type;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !Py_ENUMOBJECT_H */

python/include/errcode.h

@@ -0,0 +1,36 @@
+#ifndef Py_ERRCODE_H
+#define Py_ERRCODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Error codes passed around between file input, tokenizer, parser and
+   interpreter.  This is necessary so we can turn them into Python
+   exceptions at a higher level.  Note that some errors have a
+   slightly different meaning when passed from the tokenizer to the
+   parser than when passed from the parser to the interpreter; e.g.
+   the parser only returns E_EOF when it hits EOF immediately, and it
+   never returns E_OK. */
+
+#define E_OK		10	/* No error */
+#define E_EOF		11	/* End Of File */
+#define E_INTR		12	/* Interrupted */
+#define E_TOKEN		13	/* Bad token */
+#define E_SYNTAX	14	/* Syntax error */
+#define E_NOMEM		15	/* Ran out of memory */
+#define E_DONE		16	/* Parsing complete */
+#define E_ERROR		17	/* Execution error */
+#define E_TABSPACE	18	/* Inconsistent mixing of tabs and spaces */
+#define E_OVERFLOW      19	/* Node had too many children */
+#define E_TOODEEP	20	/* Too many indentation levels */
+#define E_DEDENT	21	/* No matching outer block for dedent */
+#define E_DECODE	22	/* Error in decoding into Unicode */
+#define E_EOFS		23	/* EOF in triple-quoted string */
+#define E_EOLS		24	/* EOL in single-quoted string */
+#define E_LINECONT	25	/* Unexpected characters after a line continuation */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_ERRCODE_H */

python/include/eval.h

@@ -0,0 +1,25 @@
+
+/* Interface to execute compiled code */
+
+#ifndef Py_EVAL_H
+#define Py_EVAL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCode(PyCodeObject *, PyObject *, PyObject *);
+
+PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyCodeObject *co,
+					PyObject *globals,
+					PyObject *locals,
+					PyObject **args, int argc,
+					PyObject **kwds, int kwdc,
+					PyObject **defs, int defc,
+					PyObject *closure);
+
+PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_EVAL_H */

python/include/fileobject.h

@@ -0,0 +1,97 @@
+
+/* File object interface */
+
+#ifndef Py_FILEOBJECT_H
+#define Py_FILEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    FILE *f_fp;
+    PyObject *f_name;
+    PyObject *f_mode;
+    int (*f_close)(FILE *);
+    int f_softspace;            /* Flag used by 'print' command */
+    int f_binary;               /* Flag which indicates whether the file is
+                               open in binary (1) or text (0) mode */
+    char* f_buf;                /* Allocated readahead buffer */
+    char* f_bufend;             /* Points after last occupied position */
+    char* f_bufptr;             /* Current buffer position */
+    char *f_setbuf;             /* Buffer for setbuf(3) and setvbuf(3) */
+    int f_univ_newline;         /* Handle any newline convention */
+    int f_newlinetypes;         /* Types of newlines seen */
+    int f_skipnextlf;           /* Skip next \n */
+    PyObject *f_encoding;
+    PyObject *f_errors;
+    PyObject *weakreflist; /* List of weak references */
+    int unlocked_count;         /* Num. currently running sections of code
+                               using f_fp with the GIL released. */
+    int readable;
+    int writable;
+} PyFileObject;
+
+PyAPI_DATA(PyTypeObject) PyFile_Type;
+
+#define PyFile_Check(op) PyObject_TypeCheck(op, &PyFile_Type)
+#define PyFile_CheckExact(op) (Py_TYPE(op) == &PyFile_Type)
+
+PyAPI_FUNC(PyObject *) PyFile_FromString(char *, char *);
+PyAPI_FUNC(void) PyFile_SetBufSize(PyObject *, int);
+PyAPI_FUNC(int) PyFile_SetEncoding(PyObject *, const char *);
+PyAPI_FUNC(int) PyFile_SetEncodingAndErrors(PyObject *, const char *, char *errors);
+PyAPI_FUNC(PyObject *) PyFile_FromFile(FILE *, char *, char *,
+                                             int (*)(FILE *));
+PyAPI_FUNC(FILE *) PyFile_AsFile(PyObject *);
+PyAPI_FUNC(void) PyFile_IncUseCount(PyFileObject *);
+PyAPI_FUNC(void) PyFile_DecUseCount(PyFileObject *);
+PyAPI_FUNC(PyObject *) PyFile_Name(PyObject *);
+PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int);
+PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int);
+PyAPI_FUNC(int) PyFile_SoftSpace(PyObject *, int);
+PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *);
+PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *);
+
+/* The default encoding used by the platform file system APIs
+   If non-NULL, this is different than the default encoding for strings
+*/
+PyAPI_DATA(const char *) Py_FileSystemDefaultEncoding;
+
+/* Routines to replace fread() and fgets() which accept any of \r, \n
+   or \r\n as line terminators.
+*/
+#define PY_STDIOTEXTMODE "b"
+char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
+size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);
+
+/* A routine to do sanity checking on the file mode string.  returns
+   non-zero on if an exception occurred
+*/
+int _PyFile_SanitizeMode(char *mode);
+
+#if defined _MSC_VER && _MSC_VER >= 1400
+/* A routine to check if a file descriptor is valid on Windows.  Returns 0
+ * and sets errno to EBADF if it isn't.  This is to avoid Assertions
+ * from various functions in the Windows CRT beginning with
+ * Visual Studio 2005
+ */
+int _PyVerify_fd(int fd);
+#elif defined _MSC_VER && _MSC_VER >= 1200
+/* fdopen doesn't set errno EBADF and crashes for large fd on debug build */
+#define _PyVerify_fd(fd) (_get_osfhandle(fd) >= 0)
+#else
+#define _PyVerify_fd(A) (1) /* dummy */
+#endif
+
+/* A routine to check if a file descriptor can be select()-ed. */
+#ifdef HAVE_SELECT
+ #define _PyIsSelectable_fd(FD) (((FD) >= 0) && ((FD) < FD_SETSIZE))
+#else
+ #define _PyIsSelectable_fd(FD) (1)
+#endif /* HAVE_SELECT */
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FILEOBJECT_H */

python/include/floatobject.h

@@ -0,0 +1,140 @@
+
+/* Float object interface */
+
+/*
+PyFloatObject represents a (double precision) floating point number.
+*/
+
+#ifndef Py_FLOATOBJECT_H
+#define Py_FLOATOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    PyObject_HEAD
+    double ob_fval;
+} PyFloatObject;
+
+PyAPI_DATA(PyTypeObject) PyFloat_Type;
+
+#define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type)
+#define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type)
+
+/* The str() precision PyFloat_STR_PRECISION is chosen so that in most cases,
+   the rounding noise created by various operations is suppressed, while
+   giving plenty of precision for practical use. */
+
+#define PyFloat_STR_PRECISION 12
+
+#ifdef Py_NAN
+#define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN)
+#endif
+
+#define Py_RETURN_INF(sign) do					\
+	if (copysign(1., sign) == 1.) {				\
+		return PyFloat_FromDouble(Py_HUGE_VAL);	\
+	} else {						\
+		return PyFloat_FromDouble(-Py_HUGE_VAL);	\
+	} while(0)
+
+PyAPI_FUNC(double) PyFloat_GetMax(void);
+PyAPI_FUNC(double) PyFloat_GetMin(void);
+PyAPI_FUNC(PyObject *) PyFloat_GetInfo(void);
+
+/* Return Python float from string PyObject.  Second argument ignored on
+   input, and, if non-NULL, NULL is stored into *junk (this tried to serve a
+   purpose once but can't be made to work as intended). */
+PyAPI_FUNC(PyObject *) PyFloat_FromString(PyObject*, char** junk);
+
+/* Return Python float from C double. */
+PyAPI_FUNC(PyObject *) PyFloat_FromDouble(double);
+
+/* Extract C double from Python float.  The macro version trades safety for
+   speed. */
+PyAPI_FUNC(double) PyFloat_AsDouble(PyObject *);
+#define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval)
+
+/* Write repr(v) into the char buffer argument, followed by null byte.  The
+   buffer must be "big enough"; >= 100 is very safe.
+   PyFloat_AsReprString(buf, x) strives to print enough digits so that
+   PyFloat_FromString(buf) then reproduces x exactly. */
+PyAPI_FUNC(void) PyFloat_AsReprString(char*, PyFloatObject *v);
+
+/* Write str(v) into the char buffer argument, followed by null byte.  The
+   buffer must be "big enough"; >= 100 is very safe.  Note that it's
+   unusual to be able to get back the float you started with from
+   PyFloat_AsString's result -- use PyFloat_AsReprString() if you want to
+   preserve precision across conversions. */
+PyAPI_FUNC(void) PyFloat_AsString(char*, PyFloatObject *v);
+
+/* _PyFloat_{Pack,Unpack}{4,8}
+ *
+ * The struct and pickle (at least) modules need an efficient platform-
+ * independent way to store floating-point values as byte strings.
+ * The Pack routines produce a string from a C double, and the Unpack
+ * routines produce a C double from such a string.  The suffix (4 or 8)
+ * specifies the number of bytes in the string.
+ *
+ * On platforms that appear to use (see _PyFloat_Init()) IEEE-754 formats
+ * these functions work by copying bits.  On other platforms, the formats the
+ * 4- byte format is identical to the IEEE-754 single precision format, and
+ * the 8-byte format to the IEEE-754 double precision format, although the
+ * packing of INFs and NaNs (if such things exist on the platform) isn't
+ * handled correctly, and attempting to unpack a string containing an IEEE
+ * INF or NaN will raise an exception.
+ *
+ * On non-IEEE platforms with more precision, or larger dynamic range, than
+ * 754 supports, not all values can be packed; on non-IEEE platforms with less
+ * precision, or smaller dynamic range, not all values can be unpacked.  What
+ * happens in such cases is partly accidental (alas).
+ */
+
+/* The pack routines write 4 or 8 bytes, starting at p.  le is a bool
+ * argument, true if you want the string in little-endian format (exponent
+ * last, at p+3 or p+7), false if you want big-endian format (exponent
+ * first, at p).
+ * Return value:  0 if all is OK, -1 if error (and an exception is
+ * set, most likely OverflowError).
+ * There are two problems on non-IEEE platforms:
+ * 1):  What this does is undefined if x is a NaN or infinity.
+ * 2):  -0.0 and +0.0 produce the same string.
+ */
+PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le);
+PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le);
+
+/* Used to get the important decimal digits of a double */
+PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum);
+PyAPI_FUNC(void) _PyFloat_DigitsInit(void);
+
+/* The unpack routines read 4 or 8 bytes, starting at p.  le is a bool
+ * argument, true if the string is in little-endian format (exponent
+ * last, at p+3 or p+7), false if big-endian (exponent first, at p).
+ * Return value:  The unpacked double.  On error, this is -1.0 and
+ * PyErr_Occurred() is true (and an exception is set, most likely
+ * OverflowError).  Note that on a non-IEEE platform this will refuse
+ * to unpack a string that represents a NaN or infinity.
+ */
+PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le);
+PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le);
+
+/* free list api */
+PyAPI_FUNC(int) PyFloat_ClearFreeList(void);
+
+/* Format the object based on the format_spec, as defined in PEP 3101
+   (Advanced String Formatting). */
+PyAPI_FUNC(PyObject *) _PyFloat_FormatAdvanced(PyObject *obj,
+					       char *format_spec,
+					       Py_ssize_t format_spec_len);
+
+/* Round a C double x to the closest multiple of 10**-ndigits.  Returns a
+   Python float on success, or NULL (with an appropriate exception set) on
+   failure.  Used in builtin_round in bltinmodule.c. */
+PyAPI_FUNC(PyObject *) _Py_double_round(double x, int ndigits);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FLOATOBJECT_H */

python/include/frameobject.h

@@ -0,0 +1,89 @@
+
+/* Frame object interface */
+
+#ifndef Py_FRAMEOBJECT_H
+#define Py_FRAMEOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int b_type;			/* what kind of block this is */
+    int b_handler;		/* where to jump to find handler */
+    int b_level;		/* value stack level to pop to */
+} PyTryBlock;
+
+typedef struct _frame {
+    PyObject_VAR_HEAD
+    struct _frame *f_back;	/* previous frame, or NULL */
+    PyCodeObject *f_code;	/* code segment */
+    PyObject *f_builtins;	/* builtin symbol table (PyDictObject) */
+    PyObject *f_globals;	/* global symbol table (PyDictObject) */
+    PyObject *f_locals;		/* local symbol table (any mapping) */
+    PyObject **f_valuestack;	/* points after the last local */
+    /* Next free slot in f_valuestack.  Frame creation sets to f_valuestack.
+       Frame evaluation usually NULLs it, but a frame that yields sets it
+       to the current stack top. */
+    PyObject **f_stacktop;
+    PyObject *f_trace;		/* Trace function */
+
+    /* If an exception is raised in this frame, the next three are used to
+     * record the exception info (if any) originally in the thread state.  See
+     * comments before set_exc_info() -- it's not obvious.
+     * Invariant:  if _type is NULL, then so are _value and _traceback.
+     * Desired invariant:  all three are NULL, or all three are non-NULL.  That
+     * one isn't currently true, but "should be".
+     */
+    PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;
+
+    PyThreadState *f_tstate;
+    int f_lasti;		/* Last instruction if called */
+    /* Call PyFrame_GetLineNumber() instead of reading this field
+       directly.  As of 2.3 f_lineno is only valid when tracing is
+       active (i.e. when f_trace is set).  At other times we use
+       PyCode_Addr2Line to calculate the line from the current
+       bytecode index. */
+    int f_lineno;		/* Current line number */
+    int f_iblock;		/* index in f_blockstack */
+    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
+    PyObject *f_localsplus[1];	/* locals+stack, dynamically sized */
+} PyFrameObject;
+
+
+/* Standard object interface */
+
+PyAPI_DATA(PyTypeObject) PyFrame_Type;
+
+#define PyFrame_Check(op) ((op)->ob_type == &PyFrame_Type)
+#define PyFrame_IsRestricted(f) \
+	((f)->f_builtins != (f)->f_tstate->interp->builtins)
+
+PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *,
+                                       PyObject *, PyObject *);
+
+
+/* The rest of the interface is specific for frame objects */
+
+/* Block management functions */
+
+PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int);
+PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *);
+
+/* Extend the value stack */
+
+PyAPI_FUNC(PyObject **) PyFrame_ExtendStack(PyFrameObject *, int, int);
+
+/* Conversions between "fast locals" and locals in dictionary */
+
+PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int);
+PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
+
+PyAPI_FUNC(int) PyFrame_ClearFreeList(void);
+
+/* Return the line of code the frame is currently executing. */
+PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FRAMEOBJECT_H */

python/include/funcobject.h

@@ -0,0 +1,76 @@
+
+/* Function object interface */
+
+#ifndef Py_FUNCOBJECT_H
+#define Py_FUNCOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Function objects and code objects should not be confused with each other:
+ *
+ * Function objects are created by the execution of the 'def' statement.
+ * They reference a code object in their func_code attribute, which is a
+ * purely syntactic object, i.e. nothing more than a compiled version of some
+ * source code lines.  There is one code object per source code "fragment",
+ * but each code object can be referenced by zero or many function objects
+ * depending only on how many times the 'def' statement in the source was
+ * executed so far.
+ */
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *func_code;	/* A code object */
+    PyObject *func_globals;	/* A dictionary (other mappings won't do) */
+    PyObject *func_defaults;	/* NULL or a tuple */
+    PyObject *func_closure;	/* NULL or a tuple of cell objects */
+    PyObject *func_doc;		/* The __doc__ attribute, can be anything */
+    PyObject *func_name;	/* The __name__ attribute, a string object */
+    PyObject *func_dict;	/* The __dict__ attribute, a dict or NULL */
+    PyObject *func_weakreflist;	/* List of weak references */
+    PyObject *func_module;	/* The __module__ attribute, can be anything */
+
+    /* Invariant:
+     *     func_closure contains the bindings for func_code->co_freevars, so
+     *     PyTuple_Size(func_closure) == PyCode_GetNumFree(func_code)
+     *     (func_closure may be NULL if PyCode_GetNumFree(func_code) == 0).
+     */
+} PyFunctionObject;
+
+PyAPI_DATA(PyTypeObject) PyFunction_Type;
+
+#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type)
+
+PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetCode(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *);
+PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *);
+PyAPI_FUNC(int) PyFunction_SetClosure(PyObject *, PyObject *);
+
+/* Macros for direct access to these values. Type checks are *not*
+   done, so use with care. */
+#define PyFunction_GET_CODE(func) \
+        (((PyFunctionObject *)func) -> func_code)
+#define PyFunction_GET_GLOBALS(func) \
+	(((PyFunctionObject *)func) -> func_globals)
+#define PyFunction_GET_MODULE(func) \
+	(((PyFunctionObject *)func) -> func_module)
+#define PyFunction_GET_DEFAULTS(func) \
+	(((PyFunctionObject *)func) -> func_defaults)
+#define PyFunction_GET_CLOSURE(func) \
+	(((PyFunctionObject *)func) -> func_closure)
+
+/* The classmethod and staticmethod types lives here, too */
+PyAPI_DATA(PyTypeObject) PyClassMethod_Type;
+PyAPI_DATA(PyTypeObject) PyStaticMethod_Type;
+
+PyAPI_FUNC(PyObject *) PyClassMethod_New(PyObject *);
+PyAPI_FUNC(PyObject *) PyStaticMethod_New(PyObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_FUNCOBJECT_H */

python/include/genobject.h

@@ -0,0 +1,40 @@
+
+/* Generator object interface */
+
+#ifndef Py_GENOBJECT_H
+#define Py_GENOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _frame; /* Avoid including frameobject.h */
+
+typedef struct {
+	PyObject_HEAD
+	/* The gi_ prefix is intended to remind of generator-iterator. */
+
+	/* Note: gi_frame can be NULL if the generator is "finished" */
+	struct _frame *gi_frame;
+
+	/* True if generator is being executed. */
+	int gi_running;
+    
+	/* The code object backing the generator */
+	PyObject *gi_code;
+
+	/* List of weak reference. */
+	PyObject *gi_weakreflist;
+} PyGenObject;
+
+PyAPI_DATA(PyTypeObject) PyGen_Type;
+
+#define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type)
+#define PyGen_CheckExact(op) (Py_TYPE(op) == &PyGen_Type)
+
+PyAPI_FUNC(PyObject *) PyGen_New(struct _frame *);
+PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GENOBJECT_H */

python/include/graminit.h

@@ -0,0 +1,87 @@
+/* Generated by Parser/pgen */
+
+#define single_input 256
+#define file_input 257
+#define eval_input 258
+#define decorator 259
+#define decorators 260
+#define decorated 261
+#define funcdef 262
+#define parameters 263
+#define varargslist 264
+#define fpdef 265
+#define fplist 266
+#define stmt 267
+#define simple_stmt 268
+#define small_stmt 269
+#define expr_stmt 270
+#define augassign 271
+#define print_stmt 272
+#define del_stmt 273
+#define pass_stmt 274
+#define flow_stmt 275
+#define break_stmt 276
+#define continue_stmt 277
+#define return_stmt 278
+#define yield_stmt 279
+#define raise_stmt 280
+#define import_stmt 281
+#define import_name 282
+#define import_from 283
+#define import_as_name 284
+#define dotted_as_name 285
+#define import_as_names 286
+#define dotted_as_names 287
+#define dotted_name 288
+#define global_stmt 289
+#define exec_stmt 290
+#define assert_stmt 291
+#define compound_stmt 292
+#define if_stmt 293
+#define while_stmt 294
+#define for_stmt 295
+#define try_stmt 296
+#define with_stmt 297
+#define with_item 298
+#define except_clause 299
+#define suite 300
+#define testlist_safe 301
+#define old_test 302
+#define old_lambdef 303
+#define test 304
+#define or_test 305
+#define and_test 306
+#define not_test 307
+#define comparison 308
+#define comp_op 309
+#define expr 310
+#define xor_expr 311
+#define and_expr 312
+#define shift_expr 313
+#define arith_expr 314
+#define term 315
+#define factor 316
+#define power 317
+#define atom 318
+#define listmaker 319
+#define testlist_comp 320
+#define lambdef 321
+#define trailer 322
+#define subscriptlist 323
+#define subscript 324
+#define sliceop 325
+#define exprlist 326
+#define testlist 327
+#define dictorsetmaker 328
+#define classdef 329
+#define arglist 330
+#define argument 331
+#define list_iter 332
+#define list_for 333
+#define list_if 334
+#define comp_iter 335
+#define comp_for 336
+#define comp_if 337
+#define testlist1 338
+#define encoding_decl 339
+#define yield_expr 340

python/include/grammar.h

@@ -0,0 +1,93 @@
+
+/* Grammar interface */
+
+#ifndef Py_GRAMMAR_H
+#define Py_GRAMMAR_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "bitset.h" /* Sigh... */
+
+/* A label of an arc */
+
+typedef struct {
+    int		 lb_type;
+    char	*lb_str;
+} label;
+
+#define EMPTY 0		/* Label number 0 is by definition the empty label */
+
+/* A list of labels */
+
+typedef struct {
+    int		 ll_nlabels;
+    label	*ll_label;
+} labellist;
+
+/* An arc from one state to another */
+
+typedef struct {
+    short	a_lbl;		/* Label of this arc */
+    short	a_arrow;	/* State where this arc goes to */
+} arc;
+
+/* A state in a DFA */
+
+typedef struct {
+    int		 s_narcs;
+    arc		*s_arc;		/* Array of arcs */
+	
+    /* Optional accelerators */
+    int		 s_lower;	/* Lowest label index */
+    int		 s_upper;	/* Highest label index */
+    int		*s_accel;	/* Accelerator */
+    int		 s_accept;	/* Nonzero for accepting state */
+} state;
+
+/* A DFA */
+
+typedef struct {
+    int		 d_type;	/* Non-terminal this represents */
+    char	*d_name;	/* For printing */
+    int		 d_initial;	/* Initial state */
+    int		 d_nstates;
+    state	*d_state;	/* Array of states */
+    bitset	 d_first;
+} dfa;
+
+/* A grammar */
+
+typedef struct {
+    int		 g_ndfas;
+    dfa		*g_dfa;		/* Array of DFAs */
+    labellist	 g_ll;
+    int		 g_start;	/* Start symbol of the grammar */
+    int		 g_accel;	/* Set if accelerators present */
+} grammar;
+
+/* FUNCTIONS */
+
+grammar *newgrammar(int start);
+dfa *adddfa(grammar *g, int type, char *name);
+int addstate(dfa *d);
+void addarc(dfa *d, int from, int to, int lbl);
+dfa *PyGrammar_FindDFA(grammar *g, int type);
+
+int addlabel(labellist *ll, int type, char *str);
+int findlabel(labellist *ll, int type, char *str);
+char *PyGrammar_LabelRepr(label *lb);
+void translatelabels(grammar *g);
+
+void addfirstsets(grammar *g);
+
+void PyGrammar_AddAccelerators(grammar *g);
+void PyGrammar_RemoveAccelerators(grammar *);
+
+void printgrammar(grammar *g, FILE *fp);
+void printnonterminals(grammar *g, FILE *fp);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_GRAMMAR_H */