1 # This script generates a Python interface for an Apple Macintosh Manager.

     2 # It uses the "bgen" package to generate C code.

     3 # The function specifications are generated by scanning the mamager's header file,

     4 # using the "scantools" package (customized for this particular manager).

     5 

     6 import string

     7 

     8 # Declarations that change for each manager

     9 MACHEADERFILE = 'QuickDraw.h'           # The Apple header file

    10 MODNAME = '_Qd'                         # The name of the module

    11 OBJECTNAME = 'Graf'                     # The basic name of the objects used here

    12 

    13 # The following is *usually* unchanged but may still require tuning

    14 MODPREFIX = 'Qd'                        # The prefix for module-wide routines

    15 OBJECTTYPE = OBJECTNAME + 'Ptr'         # The C type used to represent them

    16 OBJECTPREFIX = MODPREFIX + 'Obj'        # The prefix for object methods

    17 INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner

    18 EXTRAFILE = string.lower(MODPREFIX) + 'edit.py' # A similar file but hand-made

    19 OUTPUTFILE = MODNAME + "module.c"       # The file generated by this program

    20 

    21 from macsupport import *

    22 

    23 # Create the type objects

    24 

    25 class TextThingieClass(FixedInputBufferType):

    26     def getargsCheck(self, name):

    27         Output("/* Fool compiler warnings */")

    28         Output("%s__in_len__ = %s__in_len__;", name, name)

    29 

    30     def declareSize(self, name):

    31         Output("int %s__in_len__;", name)

    32 

    33 TextThingie = TextThingieClass(None)

    34 

    35 # These are temporary!

    36 RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")

    37 OptRgnHandle = OpaqueByValueType("RgnHandle", "OptResObj")

    38 PicHandle = OpaqueByValueType("PicHandle", "ResObj")

    39 PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")

    40 PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")

    41 PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")

    42 PatHandle = OpaqueByValueType("PatHandle", "ResObj")

    43 CursHandle = OpaqueByValueType("CursHandle", "ResObj")

    44 CCrsrHandle = OpaqueByValueType("CCrsrHandle", "ResObj")

    45 CIconHandle = OpaqueByValueType("CIconHandle", "ResObj")

    46 CTabHandle = OpaqueByValueType("CTabHandle", "ResObj")

    47 ITabHandle = OpaqueByValueType("ITabHandle", "ResObj")

    48 GDHandle = OpaqueByValueType("GDHandle", "ResObj")

    49 CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")

    50 GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")

    51 BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")

    52 const_BitMap_ptr = OpaqueByValueType("const BitMap *", "BMObj")

    53 BitMap = OpaqueType("BitMap", "BMObj_NewCopied", "BUG")

    54 RGBColor = OpaqueType('RGBColor', 'QdRGB')

    55 RGBColor_ptr = RGBColor

    56 FontInfo = OpaqueType('FontInfo', 'QdFI')

    57 Component = OpaqueByValueType('Component', 'CmpObj')

    58 ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')

    59 

    60 Cursor = StructOutputBufferType('Cursor')

    61 Cursor_ptr = StructInputBufferType('Cursor')

    62 Pattern = StructOutputBufferType('Pattern')

    63 Pattern_ptr = StructInputBufferType('Pattern')

    64 PenState = StructOutputBufferType('PenState')

    65 PenState_ptr = StructInputBufferType('PenState')

    66 TruncCode = Type("TruncCode", "h")

    67 

    68 includestuff = includestuff + """

    69 #include <Carbon/Carbon.h>

    70 

    71 #ifdef USE_TOOLBOX_OBJECT_GLUE

    72 extern PyObject *_GrafObj_New(GrafPtr);

    73 extern int _GrafObj_Convert(PyObject *, GrafPtr *);

    74 extern PyObject *_BMObj_New(BitMapPtr);

    75 extern int _BMObj_Convert(PyObject *, BitMapPtr *);

    76 extern PyObject *_QdRGB_New(RGBColorPtr);

    77 extern int _QdRGB_Convert(PyObject *, RGBColorPtr);

    78 

    79 #define GrafObj_New _GrafObj_New

    80 #define GrafObj_Convert _GrafObj_Convert

    81 #define BMObj_New _BMObj_New

    82 #define BMObj_Convert _BMObj_Convert

    83 #define QdRGB_New _QdRGB_New

    84 #define QdRGB_Convert _QdRGB_Convert

    85 #endif

    86 

    87 static PyObject *BMObj_NewCopied(BitMapPtr);

    88 

    89 /*

    90 ** Parse/generate RGB records

    91 */

    92 PyObject *QdRGB_New(RGBColorPtr itself)

    93 {

    94 

    95         return Py_BuildValue("lll", (long)itself->red, (long)itself->green, (long)itself->blue);

    96 }

    97 

    98 int QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)

    99 {

   100         long red, green, blue;

   101 

   102         if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )

   103                 return 0;

   104         p_itself->red = (unsigned short)red;

   105         p_itself->green = (unsigned short)green;

   106         p_itself->blue = (unsigned short)blue;

   107         return 1;

   108 }

   109 

   110 /*

   111 ** Generate FontInfo records

   112 */

   113 static

   114 PyObject *QdFI_New(FontInfo *itself)

   115 {

   116 

   117         return Py_BuildValue("hhhh", itself->ascent, itself->descent,

   118                         itself->widMax, itself->leading);

   119 }

   120 """

   121 

   122 finalstuff = finalstuff + """

   123 /* Like BMObj_New, but the original bitmap data structure is copied (and

   124 ** released when the object is released)

   125 */

   126 PyObject *BMObj_NewCopied(BitMapPtr itself)

   127 {

   128         BitMapObject *it;

   129         BitMapPtr itself_copy;

   130 

   131         if ((itself_copy=(BitMapPtr)malloc(sizeof(BitMap))) == NULL)

   132                 return PyErr_NoMemory();

   133         *itself_copy = *itself;

   134         it = (BitMapObject *)BMObj_New(itself_copy);

   135         it->referred_bitmap = itself_copy;

   136         return (PyObject *)it;

   137 }

   138 

   139 """

   140 

   141 variablestuff = ""

   142 

   143 initstuff = initstuff + """

   144         PyMac_INIT_TOOLBOX_OBJECT_NEW(BitMapPtr, BMObj_New);

   145         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(BitMapPtr, BMObj_Convert);

   146         PyMac_INIT_TOOLBOX_OBJECT_NEW(GrafPtr, GrafObj_New);

   147         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GrafPtr, GrafObj_Convert);

   148         PyMac_INIT_TOOLBOX_OBJECT_NEW(RGBColorPtr, QdRGB_New);

   149         PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);

   150 """

   151 

   152 ## not yet...

   153 ##

   154 ##class Region_ObjectDefinition(GlobalObjectDefinition):

   155 ##      def outputCheckNewArg(self):

   156 ##              Output("if (itself == NULL) return PyMac_Error(resNotFound);")

   157 ##      def outputFreeIt(self, itselfname):

   158 ##              Output("DisposeRegion(%s);", itselfname)

   159 ##

   160 ##class Polygon_ObjectDefinition(GlobalObjectDefinition):

   161 ##      def outputCheckNewArg(self):

   162 ##              Output("if (itself == NULL) return PyMac_Error(resNotFound);")

   163 ##      def outputFreeIt(self, itselfname):

   164 ##              Output("KillPoly(%s);", itselfname)

   165 

   166 class MyGRObjectDefinition(PEP253Mixin, GlobalObjectDefinition):

   167     getsetlist = [

   168             ('visRgn',

   169             """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */

   170             return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(self->ob_itself, h));

   171             """,

   172             None,

   173             "Convenience attribute: return a copy of the visible region"

   174             ), (

   175             'clipRgn',

   176             """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */

   177             return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(self->ob_itself, h));

   178             """,

   179             None,

   180             "Convenience attribute: return a copy of the clipping region"

   181             )]

   182     def outputCheckNewArg(self):

   183         Output("if (itself == NULL) return PyMac_Error(resNotFound);")

   184     def outputCheckConvertArg(self):

   185         Output("#if 1")

   186         OutLbrace()

   187         Output("WindowRef win;")

   188         OutLbrace("if (WinObj_Convert(v, &win) && v)")

   189         Output("*p_itself = (GrafPtr)GetWindowPort(win);")

   190         Output("return 1;")

   191         OutRbrace()

   192         Output("PyErr_Clear();")

   193         OutRbrace()

   194         Output("#else")

   195         OutLbrace("if (DlgObj_Check(v))")

   196         Output("DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;")

   197         Output("*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));")

   198         Output("return 1;")

   199         OutRbrace()

   200         OutLbrace("if (WinObj_Check(v))")

   201         Output("WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;")

   202         Output("*p_itself = (GrafPtr)GetWindowPort(win);")

   203         Output("return 1;")

   204         OutRbrace()

   205         Output("#endif")

   206 

   207 class MyBMObjectDefinition(PEP253Mixin, GlobalObjectDefinition):

   208     getsetlist = [

   209     (

   210     'baseAddr',

   211     'return PyInt_FromLong((long)self->ob_itself->baseAddr);',

   212     None,

   213     None

   214     ), (

   215     'rowBytes',

   216     'return PyInt_FromLong((long)self->ob_itself->rowBytes);',

   217     None,

   218     None

   219     ), (

   220     'bounds',

   221     'return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);',

   222     None,

   223     None

   224     ), (

   225     'bitmap_data',

   226     'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));',

   227     None,

   228     None

   229     ), (

   230     'pixmap_data',

   231     'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));',

   232     None,

   233     None

   234     )]

   235     def outputCheckNewArg(self):

   236         Output("if (itself == NULL) return PyMac_Error(resNotFound);")

   237     def outputStructMembers(self):

   238         # We need to more items: a pointer to privately allocated data

   239         # and a python object we're referring to.

   240         Output("%s ob_itself;", self.itselftype)

   241         Output("PyObject *referred_object;")

   242         Output("BitMap *referred_bitmap;")

   243     def outputInitStructMembers(self):

   244         Output("it->ob_itself = %sitself;", self.argref)

   245         Output("it->referred_object = NULL;")

   246         Output("it->referred_bitmap = NULL;")

   247     def outputCleanupStructMembers(self):

   248         Output("Py_XDECREF(self->referred_object);")

   249         Output("if (self->referred_bitmap) free(self->referred_bitmap);")

   250 

   251 # Create the generator groups and link them

   252 module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff, variablestuff)

   253 ##r_object = Region_ObjectDefinition('Region', 'QdRgn', 'RgnHandle')

   254 ##po_object = Polygon_ObjectDefinition('Polygon', 'QdPgn', 'PolyHandle')

   255 ##module.addobject(r_object)

   256 ##module.addobject(po_object)

   257 gr_object = MyGRObjectDefinition("GrafPort", "GrafObj", "GrafPtr")

   258 module.addobject(gr_object)

   259 bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")

   260 module.addobject(bm_object)

   261 

   262 

   263 # Create the generator classes used to populate the lists

   264 Function = OSErrWeakLinkFunctionGenerator

   265 Method = OSErrWeakLinkMethodGenerator

   266 

   267 # Create and populate the lists

   268 functions = []

   269 gr_methods = []

   270 bm_methods = []

   271 #methods = []

   272 execfile(INPUTFILE)

   273 execfile(EXTRAFILE)

   274 

   275 # add the populated lists to the generator groups

   276 # (in a different wordl the scan program would generate this)

   277 for f in functions: module.add(f)

   278 for f in gr_methods: gr_object.add(f)

   279 for f in bm_methods: bm_object.add(f)

   280 

   281 # Manual generator: get data out of a bitmap

   282 getdata_body = """

   283 int from, length;

   284 char *cp;

   285 

   286 if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )

   287         return NULL;

   288 cp = _self->ob_itself->baseAddr+from;

   289 _res = PyString_FromStringAndSize(cp, length);

   290 return _res;

   291 """

   292 f = ManualGenerator("getdata", getdata_body)

   293 f.docstring = lambda: """(int start, int size) -> string. Return bytes from the bitmap"""

   294 bm_object.add(f)

   295 

   296 # Manual generator: store data in a bitmap

   297 putdata_body = """

   298 int from, length;

   299 char *cp, *icp;

   300 

   301 if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )

   302         return NULL;

   303 cp = _self->ob_itself->baseAddr+from;

   304 memcpy(cp, icp, length);

   305 Py_INCREF(Py_None);

   306 _res = Py_None;

   307 return _res;

   308 """

   309 f = ManualGenerator("putdata", putdata_body)

   310 f.docstring = lambda: """(int start, string data). Store bytes into the bitmap"""

   311 bm_object.add(f)

   312 

   313 #

   314 # We manually generate a routine to create a BitMap from python data.

   315 #

   316 BitMap_body = """

   317 BitMap *ptr;

   318 PyObject *source;

   319 Rect bounds;

   320 int rowbytes;

   321 char *data;

   322 

   323 if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,

   324                 &bounds) )

   325         return NULL;

   326 data = PyString_AsString(source);

   327 if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )

   328         return PyErr_NoMemory();

   329 ptr->baseAddr = (Ptr)data;

   330 ptr->rowBytes = rowbytes;

   331 ptr->bounds = bounds;

   332 if ( (_res = BMObj_New(ptr)) == NULL ) {

   333         free(ptr);

   334         return NULL;

   335 }

   336 ((BitMapObject *)_res)->referred_object = source;

   337 Py_INCREF(source);

   338 ((BitMapObject *)_res)->referred_bitmap = ptr;

   339 return _res;

   340 """

   341 

   342 f = ManualGenerator("BitMap", BitMap_body)

   343 f.docstring = lambda: """Take (string, int, Rect) argument and create BitMap"""

   344 module.add(f)

   345 

   346 #

   347 # And again, for turning a correctly-formatted structure into the object

   348 #

   349 RawBitMap_body = """

   350 BitMap *ptr;

   351 PyObject *source;

   352 

   353 if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )

   354         return NULL;

   355 if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {

   356         PyErr_Format(PyExc_TypeError,

   357                 "Argument size was %d, should be %d (sizeof BitMap) or %d (sizeof PixMap)",

   358                 PyString_Size(source), sizeof(BitMap), sizeof(PixMap));

   359         return NULL;

   360 }

   361 ptr = (BitMapPtr)PyString_AsString(source);

   362 if ( (_res = BMObj_New(ptr)) == NULL ) {

   363         return NULL;

   364 }

   365 ((BitMapObject *)_res)->referred_object = source;

   366 Py_INCREF(source);

   367 return _res;

   368 """

   369 

   370 f = ManualGenerator("RawBitMap", RawBitMap_body)

   371 f.docstring = lambda: """Take string BitMap and turn into BitMap object"""

   372 module.add(f)

   373 

   374 # generate output (open the output file as late as possible)

   375 SetOutputFileName(OUTPUTFILE)

   376 module.generate()

   377 SetOutputFile() # Close it