cpython/Mac/Modules/qd/qdsupport.py

# This script generates a Python interface for an Apple Macintosh Manager.
# It uses the "bgen" package to generate C code.
# The function specifications are generated by scanning the mamager's header file,
# using the "scantools" package (customized for this particular manager).

import string

# Declarations that change for each manager
MACHEADERFILE = 'QuickDraw.h'           # The Apple header file
MODNAME = '_Qd'                         # The name of the module
OBJECTNAME = 'Graf'                     # The basic name of the objects used here

# The following is *usually* unchanged but may still require tuning
MODPREFIX = 'Qd'                        # The prefix for module-wide routines
OBJECTTYPE = OBJECTNAME + 'Ptr'         # The C type used to represent them
OBJECTPREFIX = MODPREFIX + 'Obj'        # The prefix for object methods
INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
EXTRAFILE = string.lower(MODPREFIX) + 'edit.py' # A similar file but hand-made
OUTPUTFILE = MODNAME + "module.c"       # The file generated by this program

from macsupport import *

# Create the type objects

class TextThingieClass(FixedInputBufferType):
    def getargsCheck(self, name):
        Output("/* Fool compiler warnings */")
        Output("%s__in_len__ = %s__in_len__;", name, name)

    def declareSize(self, name):
        Output("int %s__in_len__;", name)

TextThingie = TextThingieClass(None)

# These are temporary!
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
OptRgnHandle = OpaqueByValueType("RgnHandle", "OptResObj")
PicHandle = OpaqueByValueType("PicHandle", "ResObj")
PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")
PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
PatHandle = OpaqueByValueType("PatHandle", "ResObj")
CursHandle = OpaqueByValueType("CursHandle", "ResObj")
CCrsrHandle = OpaqueByValueType("CCrsrHandle", "ResObj")
CIconHandle = OpaqueByValueType("CIconHandle", "ResObj")
CTabHandle = OpaqueByValueType("CTabHandle", "ResObj")
ITabHandle = OpaqueByValueType("ITabHandle", "ResObj")
GDHandle = OpaqueByValueType("GDHandle", "ResObj")
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
GrafPtr = OpaqueByValueType("GrafPtr", "GrafObj")
BitMap_ptr = OpaqueByValueType("BitMapPtr", "BMObj")
const_BitMap_ptr = OpaqueByValueType("const BitMap *", "BMObj")
BitMap = OpaqueType("BitMap", "BMObj_NewCopied", "BUG")
RGBColor = OpaqueType('RGBColor', 'QdRGB')
RGBColor_ptr = RGBColor
FontInfo = OpaqueType('FontInfo', 'QdFI')
Component = OpaqueByValueType('Component', 'CmpObj')
ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')

Cursor = StructOutputBufferType('Cursor')
Cursor_ptr = StructInputBufferType('Cursor')
Pattern = StructOutputBufferType('Pattern')
Pattern_ptr = StructInputBufferType('Pattern')
PenState = StructOutputBufferType('PenState')
PenState_ptr = StructInputBufferType('PenState')
TruncCode = Type("TruncCode", "h")

includestuff = includestuff + """
#include <Carbon/Carbon.h>

#ifdef USE_TOOLBOX_OBJECT_GLUE
extern PyObject *_GrafObj_New(GrafPtr);
extern int _GrafObj_Convert(PyObject *, GrafPtr *);
extern PyObject *_BMObj_New(BitMapPtr);
extern int _BMObj_Convert(PyObject *, BitMapPtr *);
extern PyObject *_QdRGB_New(RGBColorPtr);
extern int _QdRGB_Convert(PyObject *, RGBColorPtr);

#define GrafObj_New _GrafObj_New
#define GrafObj_Convert _GrafObj_Convert
#define BMObj_New _BMObj_New
#define BMObj_Convert _BMObj_Convert
#define QdRGB_New _QdRGB_New
#define QdRGB_Convert _QdRGB_Convert
#endif

static PyObject *BMObj_NewCopied(BitMapPtr);

/*
** Parse/generate RGB records
*/
PyObject *QdRGB_New(RGBColorPtr itself)
{

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

int QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)
{
        long red, green, blue;

        if( !PyArg_ParseTuple(v, "lll", &red, &green, &blue) )
                return 0;
        p_itself->red = (unsigned short)red;
        p_itself->green = (unsigned short)green;
        p_itself->blue = (unsigned short)blue;
        return 1;
}

/*
** Generate FontInfo records
*/
static
PyObject *QdFI_New(FontInfo *itself)
{

        return Py_BuildValue("hhhh", itself->ascent, itself->descent,
                        itself->widMax, itself->leading);
}
"""

finalstuff = finalstuff + """
/* Like BMObj_New, but the original bitmap data structure is copied (and
** released when the object is released)
*/
PyObject *BMObj_NewCopied(BitMapPtr itself)
{
        BitMapObject *it;
        BitMapPtr itself_copy;

        if ((itself_copy=(BitMapPtr)malloc(sizeof(BitMap))) == NULL)
                return PyErr_NoMemory();
        *itself_copy = *itself;
        it = (BitMapObject *)BMObj_New(itself_copy);
        it->referred_bitmap = itself_copy;
        return (PyObject *)it;
}

"""

variablestuff = ""

initstuff = initstuff + """
        PyMac_INIT_TOOLBOX_OBJECT_NEW(BitMapPtr, BMObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(BitMapPtr, BMObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(GrafPtr, GrafObj_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(GrafPtr, GrafObj_Convert);
        PyMac_INIT_TOOLBOX_OBJECT_NEW(RGBColorPtr, QdRGB_New);
        PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);
"""

## not yet...
##
##class Region_ObjectDefinition(GlobalObjectDefinition):
##      def outputCheckNewArg(self):
##              Output("if (itself == NULL) return PyMac_Error(resNotFound);")
##      def outputFreeIt(self, itselfname):
##              Output("DisposeRegion(%s);", itselfname)
##
##class Polygon_ObjectDefinition(GlobalObjectDefinition):
##      def outputCheckNewArg(self):
##              Output("if (itself == NULL) return PyMac_Error(resNotFound);")
##      def outputFreeIt(self, itselfname):
##              Output("KillPoly(%s);", itselfname)

class MyGRObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
    getsetlist = [
            ('visRgn',
            """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortVisibleRegion(self->ob_itself, h));
            """,
            None,
            "Convenience attribute: return a copy of the visible region"
            ), (
            'clipRgn',
            """RgnHandle h=NewRgn(); /* XXXX wrong dispose routine */
            return Py_BuildValue("O&", ResObj_New, (Handle)GetPortClipRegion(self->ob_itself, h));
            """,
            None,
            "Convenience attribute: return a copy of the clipping region"
            )]
    def outputCheckNewArg(self):
        Output("if (itself == NULL) return PyMac_Error(resNotFound);")
    def outputCheckConvertArg(self):
        Output("#if 1")
        OutLbrace()
        Output("WindowRef win;")
        OutLbrace("if (WinObj_Convert(v, &win) && v)")
        Output("*p_itself = (GrafPtr)GetWindowPort(win);")
        Output("return 1;")
        OutRbrace()
        Output("PyErr_Clear();")
        OutRbrace()
        Output("#else")
        OutLbrace("if (DlgObj_Check(v))")
        Output("DialogRef dlg = (DialogRef)((GrafPortObject *)v)->ob_itself;")
        Output("*p_itself = (GrafPtr)GetWindowPort(GetDialogWindow(dlg));")
        Output("return 1;")
        OutRbrace()
        OutLbrace("if (WinObj_Check(v))")
        Output("WindowRef win = (WindowRef)((GrafPortObject *)v)->ob_itself;")
        Output("*p_itself = (GrafPtr)GetWindowPort(win);")
        Output("return 1;")
        OutRbrace()
        Output("#endif")

class MyBMObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
    getsetlist = [
    (
    'baseAddr',
    'return PyInt_FromLong((long)self->ob_itself->baseAddr);',
    None,
    None
    ), (
    'rowBytes',
    'return PyInt_FromLong((long)self->ob_itself->rowBytes);',
    None,
    None
    ), (
    'bounds',
    'return Py_BuildValue("O&", PyMac_BuildRect, &self->ob_itself->bounds);',
    None,
    None
    ), (
    'bitmap_data',
    'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(BitMap));',
    None,
    None
    ), (
    'pixmap_data',
    'return PyString_FromStringAndSize((char *)self->ob_itself, sizeof(PixMap));',
    None,
    None
    )]
    def outputCheckNewArg(self):
        Output("if (itself == NULL) return PyMac_Error(resNotFound);")
    def outputStructMembers(self):
        # We need to more items: a pointer to privately allocated data
        # and a python object we're referring to.
        Output("%s ob_itself;", self.itselftype)
        Output("PyObject *referred_object;")
        Output("BitMap *referred_bitmap;")
    def outputInitStructMembers(self):
        Output("it->ob_itself = %sitself;", self.argref)
        Output("it->referred_object = NULL;")
        Output("it->referred_bitmap = NULL;")
    def outputCleanupStructMembers(self):
        Output("Py_XDECREF(self->referred_object);")
        Output("if (self->referred_bitmap) free(self->referred_bitmap);")

# Create the generator groups and link them
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff, variablestuff)
##r_object = Region_ObjectDefinition('Region', 'QdRgn', 'RgnHandle')
##po_object = Polygon_ObjectDefinition('Polygon', 'QdPgn', 'PolyHandle')
##module.addobject(r_object)
##module.addobject(po_object)
gr_object = MyGRObjectDefinition("GrafPort", "GrafObj", "GrafPtr")
module.addobject(gr_object)
bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")
module.addobject(bm_object)


# Create the generator classes used to populate the lists
Function = OSErrWeakLinkFunctionGenerator
Method = OSErrWeakLinkMethodGenerator

# Create and populate the lists
functions = []
gr_methods = []
bm_methods = []
#methods = []
exec(open(INPUTFILE).read())
exec(open(EXTRAFILE).read())

# add the populated lists to the generator groups
# (in a different wordl the scan program would generate this)
for f in functions: module.add(f)
for f in gr_methods: gr_object.add(f)
for f in bm_methods: bm_object.add(f)

# Manual generator: get data out of a bitmap
getdata_body = """
int from, length;
char *cp;

if ( !PyArg_ParseTuple(_args, "ii", &from, &length) )
        return NULL;
cp = _self->ob_itself->baseAddr+from;
_res = PyString_FromStringAndSize(cp, length);
return _res;
"""
f = ManualGenerator("getdata", getdata_body)
f.docstring = lambda: """(int start, int size) -> string. Return bytes from the bitmap"""
bm_object.add(f)

# Manual generator: store data in a bitmap
putdata_body = """
int from, length;
char *cp, *icp;

if ( !PyArg_ParseTuple(_args, "is#", &from, &icp, &length) )
        return NULL;
cp = _self->ob_itself->baseAddr+from;
memcpy(cp, icp, length);
Py_INCREF(Py_None);
_res = Py_None;
return _res;
"""
f = ManualGenerator("putdata", putdata_body)
f.docstring = lambda: """(int start, string data). Store bytes into the bitmap"""
bm_object.add(f)

#
# We manually generate a routine to create a BitMap from python data.
#
BitMap_body = """
BitMap *ptr;
PyObject *source;
Rect bounds;
int rowbytes;
char *data;

if ( !PyArg_ParseTuple(_args, "O!iO&", &PyString_Type, &source, &rowbytes, PyMac_GetRect,
                &bounds) )
        return NULL;
data = PyString_AsString(source);
if ((ptr=(BitMap *)malloc(sizeof(BitMap))) == NULL )
        return PyErr_NoMemory();
ptr->baseAddr = (Ptr)data;
ptr->rowBytes = rowbytes;
ptr->bounds = bounds;
if ( (_res = BMObj_New(ptr)) == NULL ) {
        free(ptr);
        return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
((BitMapObject *)_res)->referred_bitmap = ptr;
return _res;
"""

f = ManualGenerator("BitMap", BitMap_body)
f.docstring = lambda: """Take (string, int, Rect) argument and create BitMap"""
module.add(f)

#
# And again, for turning a correctly-formatted structure into the object
#
RawBitMap_body = """
BitMap *ptr;
PyObject *source;

if ( !PyArg_ParseTuple(_args, "O!", &PyString_Type, &source) )
        return NULL;
if ( PyString_Size(source) != sizeof(BitMap) && PyString_Size(source) != sizeof(PixMap) ) {
        PyErr_Format(PyExc_TypeError,
                "Argument size was %d, should be %d (sizeof BitMap) or %d (sizeof PixMap)",
                PyString_Size(source), sizeof(BitMap), sizeof(PixMap));
        return NULL;
}
ptr = (BitMapPtr)PyString_AsString(source);
if ( (_res = BMObj_New(ptr)) == NULL ) {
        return NULL;
}
((BitMapObject *)_res)->referred_object = source;
Py_INCREF(source);
return _res;
"""

f = ManualGenerator("RawBitMap", RawBitMap_body)
f.docstring = lambda: """Take string BitMap and turn into BitMap object"""
module.add(f)

# generate output (open the output file as late as possible)
SetOutputFileName(OUTPUTFILE)
module.generate()
SetOutputFile() # Close it