HOWTO: Compiling Python Modules with MPW

From: Jack Jansen Date: Sat, 22 Apr 2000 21:48:56 +0000 (+0000) Subject: Added Corran Webster's explanation of how to write extensions in MPW and a pointer... X-Git-Tag: v2.0b1~1976 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=968cde98fcac0ca911bc39e3b1d2c2945a8d0447;p=python Added Corran Webster's explanation of how to write extensions in MPW and a pointer to his W documentation. --- diff --git a/Mac/Demo/html.icons/createmake.png b/Mac/Demo/html.icons/createmake.png new file mode 100644 index 0000000000..50d6fa550e Binary files /dev/null and b/Mac/Demo/html.icons/createmake.png differ diff --git a/Mac/Demo/index.html b/Mac/Demo/index.html index 9845c20194..26b08cc829 100644 --- a/Mac/Demo/index.html +++ b/Mac/Demo/index.html @@ -27,11 +27,17 @@ in PostScript and other forms, see the documentation section on the webserver.

-Some of these documents were actually written a long time ago and have seen -little maintainance, so use with care.

+The W widget set by Just van Rossum, which is used by the Python IDE, does not +have complete documentation as of this writing, but Corran Webster has +documented most of it on his +Python Page. +

Note: +Some of these documents were actually written a long time ago and have seen +little maintainance, so use with care.

Using python to create Macintosh applications, @@ -71,7 +77,12 @@ WASTE, an extended TextEdit replacement. is meant for the hardcore programmer, and shows how to create an extension module in C. It also handles using Modulator to create the boilerplate for your module, and creating dynamically-loadable modules -on PowerPC Macs. +on PowerPC Macs. It assumes you use CodeWarrior for you development. + +
+Creating C extension modules using MPW +is a companion document, written by Corran Webster, which explains how you +can develop Python extensions using Apple's free MPW compiler environment.
Using Open Scripting Architecture from Python explains @@ -140,5 +151,5 @@ documentation.

Jack Jansen, -jack@cwi.nl, 26-Jun-98. +jack@cwi.nl, 22-Apr-00. diff --git a/Mac/Demo/mpwextensions.html b/Mac/Demo/mpwextensions.html new file mode 100644 index 0000000000..742cbc2812 --- /dev/null +++ b/Mac/Demo/mpwextensions.html @@ -0,0 +1,484 @@ + + + + + +HOWTO: Compiling Python Modules with MPW + + + + + +
HOWTO: Compiling Python Modules with MPW
+ +
+This HOWTO is a slightly reformatted version of an original by +Corran Webster, whose +Python page +may contain a more up-to-date version. +
+
+ +
+The Macintosh version +of the Python programming language is +usually compiled with Metrowerks +CodeWarrior. As a result, C extension modules are also usually +compiled with CodeWarrior, and the documentation and sample code reflects +this. CodeWarrior is a commercial product, and may be beyond the budgets +of hobbyist hackers, making them dependent on others to compile C extension +modules. At the present time, many standard C extension modules compile +"out of the box" on the Macintosh, but in only a few cases is the plugin +for the Macintosh included in the distribution. +
+ +
+The Macintosh +Programmer's Workshop (MPW) is Apple's development environment, and is +freely available for download +from Apple, as well as on their Developer CDs. Since Python was originally +developed using MPW, before CodeWarrior became the dominant MacOS +development environment, most of the idiosyncrasies of MPW are already +supported, and compilation of C extension modules in MPW is possible. +
+ +
+This HOWTO only deals with compiling for PowerPC Macintoshes. The process +should be similar for 68k Macintoshes using the code fragment manager, but +I have not attempted this - my old Mac is running NetBSD. +
+ +
+This way of compiling modules is still experimental. Please read the +caveats section below. +
+ +
Setting Up MPW for Compiling Python Modules
+ +
+This assumes that you have successfully installed both MPW and Python with +the Developer's Kit on your Macintosh. +
+ +
+The first step is to let MPW know where you keep Python. This step is not +strictly necessary, but will make development easier and improve +portability. Create a new file in the Startup Items folder of +MPW called Python. Type the lines: +
+ +
```
+set Python "Macintosh HD:Applications:Python 1.5.2c1:"
+set PythonIncludes "{Python}Include"
+set PythonMacIncludes "{Python}Mac:Include"
+set PythonCore "{Python}PythonCore"
+
+export Python PythonIncludes PythonMacIncludes PythonCore
+
```
+ +
+where Macintosh HD:Applications:Python 1.5.2c1: is replaced by +the path to the directory where you keep your copy of Python, and the other +variables reflect where you keep your header files and Python core files. +The locations here are the standard for Python 1.5.2c1, but they are +different for Python 1.52b2 and earlier (most notably, the PythonCore is +kept in the Extensions folder). +
+ +
+Next, you need to update the config.h +file for the MrC compiler included with MPW. This header file +is located in the :Mac:Include folder in the standard +distribution. You can update it by hand, by adding the lines: +
+ +
```
+#ifdef __MRC__
+#define BAD_STATIC_FORWARD
+#endif
+
```
+ +
+at the after the similar defines for __MWERKS__ and +__SC__ in the file. This step is critical: many modules, +including ones in the standard distribution, will not compile properly +without this modification (see common problems below). +
+ +
+Copies of both the Python startup item +for MPW and the config.h are included +here for your convenience. +
+ +
+If you are porting Unix modules to the mac, you may find it useful to +install GUSI for +your copy of MPW. GUSI provides some amount of POSIX compatibility, and is +used by Python itself for this purpose - at the very least having it's +header files available may be useful. Also of note for people porting Unix +modules, the most recent alpha version (4.1a8) of MrC and +MrCpp at this writing permits using unix-style pathnames for +includes via the -includes unix command line option. I have +not experimented heavily with this, but will be doing so in the future and +report my findings. +
+ +
+You now have MPW and Python set up to allow compilation of modules. +
+ +
Compiling a Module
+ +
+This assumes that you have a C extension module ready to compile. For +instructions on how to write a module, see the Python documentation. +
+ +
+There are three approaches you can take to compiling in MPW: using the +command line interface, using the MPW CreateMake command +(available as the "Create build commands..." menu item, and writing a +Makefile by hand. +
+ +
+Before you start any of these, you'll need to know: +
+ +
- The names and locations of the C source files. In the examples, this + is the file xxmodule.c, and is in + MPW's current working directory. +
- The name that Python expects to import your module under. In the + examples, this is xx, so the shared library file will be + called xx.ppc.slb. +
- The location of any additional header files use by the C source. The + example does not use any additional header files. +
- The location of any additional shared libraries which the module needs + to link to. The example does not link to any other shared libraries. +
- The name of the entry point to your module. This is usually the last + function in the main C source file, and the name usually starts with + init. In the examples, this is initxx. +
+ +
Using the Command Line
+ +
+For simple modules consisting of one or two C files, it's often convenient +to simply use commands in a MPW Worksheet. Usually you will want to set +MPW's working directory to the directory containing the C source code. The +following commands compile and link the standard Python test module xxmodule.c: +
+ +
```
+MrC "xxmodule.c" -o "xx.c.x" -w off  -d HAVE_CONFIG_H ∂
+        -i "{PythonMacIncludes}" ∂
+        -i "{PythonIncludes}" 
+PPCLink ∂
+        -o "xx.ppc.slb"  ∂
+        "xx.c.x" ∂
+        -t 'shlb' ∂
+        -c 'Pyth' ∂
+        -xm s ∂
+        -d ∂
+        "{PythonCore}" ∂
+        "{SharedLibraries}InterfaceLib" ∂
+        "{SharedLibraries}MathLib" ∂
+        "{SharedLibraries}StdCLib" ∂
+        "{PPCLibraries}StdCRuntime.o" ∂
+        "{PPCLibraries}PPCCRuntime.o" ∂
+        "{PPCLibraries}PPCToolLibs.o" ∂
+        -export initxx
+
```
+ +
+(Note: The last character on each line should appear as "partial +derivative" symbol, which you type as option-d and which is +MPW's line continuation symbol.) +
+ +
+Any additional header files should be specified by adding their directories +as extra -i options to the MrC command. Any +additional shared libraries should be added before the PythonCore library +in the PPCLink command. +
+ +
+If there is more than one source file, you will need to duplicate the +compile command for each source file, and you will need to include all the +object files in the place where "xx.c.x" appears in the +PPCLink command. +
+ +
Using CreateMake
+ +
+For more complex modules, or modules that you are writing yourself, you +will probably want to use a makefile. Unfortunately MPW's makefiles are +incompatible with the standard Unix makefiles, so you will not be able to +use any makefiles which come with a C module. +
+ +
+Usually, you will want the makefile to reside in the same directory as the +C source code, so you should set MPW's working directory to that directory +before proceeding. +
+ +
+To create a makefile for the standard Python test module xxmodule.c: +
+ +
- Select "Create build commands..." from the "Build" Menu. +
- Type xx.ppc.slb for the Program Name. +
- Select "Shared Library" for the Program Type. +
- Select "PowerPC Only" for the Target. +
- Click on the "Source Files..." button, and add your module's C source + files to the list. +
- Click on the "Other Options..." button and change the creator type to + "Pyth". If you are using additional header files, you can also add their + directories at this stage. Click on "Continue" once you have done this. +
- Click on the "Exported Symbols..." button and type initxx + into the entry field. Click on "Continue" once you have done this. +
- At this stage, your CreateMake window should look like this: +
- Click on the "CreateMake" button. +
+ +
+You will now need to edit the makefile that was just created. Open the +file "xx.ppc.slb.make" in the current directory and make the following +changes: +
+ +
- Change the line + +
```
+Includes     =
+
```
  + +
  + to read +
  + +
```
+Includes     = -i "{PythonIncludes}" -i "{PythonMacIncludes}"
+
```
  + +
  + If you have any additional headers than need to be included, you can add + them here as well. +
- Change the line + +
```
+PPCCOptions  = {Includes} {Sym•PPC} 
+
```
  + +
  + to read +
  + +
```
+PPCCOptions  = -w off  -d HAVE_CONFIG_H {Includes} {Sym•PPC} 
+
```
  + +
  +
- After the line + +
```
+                -xm s ∂
+
```
  + +
  + add +
  + +
```
+                -d ∂
+                "{PythonCore}" ∂
+
```
  + +
  + If you have any other shared libraries you need to link to, add each on a + line before PythonCore, terminating each line with a ∂. +
  + +
+ +
Save the file. You are now ready to build. +
+ +
+Go to the "Build" or "Full Build" menu items, type in +xx.ppc.slb, and MPW should take things from there. Any time you +need to rebuild the shared library, you can simply do another "Build" or +"Full Build". +
+ +
Writing a Makefile by Hand
+ +
+For modules which have complex interdependencies between files, you will +likely need a more sophisticated makefile than the one created by +CreateMake. You will need to be familiar with the MPW +makefile format, but you can get a start by either using +CreateMake to get a simple starting point, or taking another +MPW makefile as a starting point. +
+ +
+It is beyond the scope of this HOWTO to go into the generalities of MPW +makefiles. Documentation on MPW's Make command can be found +with the MPW distribution, in particular the documents Building +and Maintaining Programs with MPW (2nd Edition) and the MPW +Command Reference. +
+ +
+There are a couple of important points to keep in mind when writing a +makefile by hand:
+ +
- When there are multiple symbols with the same name in object files or + shared libraries, PPCLink used the symbol from the file which + appears first in arguments of the PPCLink command. For this + reason, you will usually want the PythonCore and any other shared libraries + which are not part of the standard MPW runtime environment to appear before + the standard runtime libraries. This is particularly the case with + StdCLib. The "-d" option turns off the (often copious) warnings about + multiply defined symbols. +
- You will want to make sure that the HAVE_CONFIG_H + preprocessor symbol is defined for most C source files using the -d + HAVE_CONFIG_H option to MrC. +
+ +
+The file xx.ppc.slb.make +is included here for you to use as a starting point. +
+ +
Using the Extension Module
+ +
+Once you have compiled your extension module, you will need to let Python +know where it is. You can either move it into a place on Python's search +path - such as the :Mac:Plugins folder - or modify the path to +include the location of your new module using the +EditPythonPrefs applet. +
+ +
+Your work may not be completely done, as many extension modules have a +Python wrapper around them. If the Python was not written with portability +in mind, you may need to do some more work to get that up and running. +Indeed, if the Python part uses OS-specific features, like pipes, you may +have to completely rewrite it if you can make it work at all. +
+ +
Common Problems
+ +
+There are a couple of common problems which occur when porting a module +from another platform. Fortunately, they are often easy to fix. +
+ +
Static Forward Definitions
+ +
+If you get a compiler error which looks something like: +
+ +
```
+File "xxmodule.c"; line 135 #Error: 'Xxo_Type' is already defined
+
```
+ +
+then most likely either you have not set up config.h correctly +to handle static forward definitions, or the module author has not adhered +to the standard python conventions. If the second is the case, find where +the variable is first defined, and replace the static with +staticforward. Then find the second place it is defined +(usually the line where the compiler complained) and replace +static with statichere. +
+ +
+If you have set up things correctly, you should now be able to compile. +
+ +
Automatic Type Conversion
+ +
+MrC seems to be a little pickier about automatically +converting from one type to another than some other C compilers. These can +often be fixed by simply adding an explicit cast to the desired type. +
+ +
+XXX There may be a compiler option which relaxes this. That would be a +better solution. +
+ +
Caveats
+ +
+As Jack Jansen pointed out on the Mac Python mailing list, there could +potentially be conflicts between the MetroWerks C runtime which the Python +core and standard modules was compiled with, and the MPW C runtime which +your extension module is compiled with. While things seem to work fine in +everyday use, it is possible that there are bugs which have not been +discovered yet. Most likely these world take the form of standard C +functions (most likely I/O functions due to conflicts between the SIOUX +libraries and the SIOW libraries) not working as they are supposed to, or +memory leaks caused by improper malloc/free. +
+ +
+Some such problems have been demonstrated by compiling modules with +PythonCore linked after StdCLib - printf does not work properly in this +setup, and I suspect that there will also be malloc/free problems in +situations where the module allocates memory which is later disposed of by +Python, or vice-versa. Compiling with PythonCore taking precedence over +StdCLib seems to give the correct behaviour. +
+ +
+This method of compiling should be considered experimental for the time +being. Use it at your own risk. +
+ +
+If you notice any quirks in modules compiled this way, or have insight into +what may go wrong or right with this situation, please contact me so that I can add +it to the HOWTO. +
+ +
+The ideal solution to this problem would be to get Python to compile using +MPW (and a Python MPW Tool would be very neat indeed). However, that does +seem to be a major project. +
+ +
+
+
+©Corran Webster, 1999.
+ +Last modified 14/12/99 12:17 PM + +
+ + + +

Table of contents

HOWTO: Compiling Python Modules with MPW

Setting Up MPW for Compiling Python Modules

Compiling a Module

Using the Command Line

Using CreateMake

Writing a Makefile by Hand

Using the Extension Module

Common Problems

Static Forward Definitions

Automatic Type Conversion

Caveats