qdsupport.py 11.6 KB
Newer Older
1 2 3 4 5 6 7 8 9
# 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
10
MODNAME = '_Qd'				# The name of the module
11 12 13
OBJECTNAME = 'Graf'			# The basic name of the objects used here

# The following is *usually* unchanged but may still require tuning
14
MODPREFIX = 'Qd'			# The prefix for module-wide routines
15 16 17 18 19 20 21 22 23 24
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

25 26
class TextThingieClass(FixedInputBufferType):
	def getargsCheck(self, name):
27 28 29 30 31
		Output("/* Fool compiler warnings */")
		Output("%s__in_len__ = %s__in_len__;", name, name)

	def declareSize(self, name):
		Output("int %s__in_len__;", name)
32 33 34 35 36

TextThingie = TextThingieClass(None)

# These are temporary!
RgnHandle = OpaqueByValueType("RgnHandle", "ResObj")
37
OptRgnHandle = OpaqueByValueType("RgnHandle", "OptResObj")
38 39 40 41
PicHandle = OpaqueByValueType("PicHandle", "ResObj")
PolyHandle = OpaqueByValueType("PolyHandle", "ResObj")
PixMapHandle = OpaqueByValueType("PixMapHandle", "ResObj")
PixPatHandle = OpaqueByValueType("PixPatHandle", "ResObj")
42 43
PatHandle = OpaqueByValueType("PatHandle", "ResObj")
CursHandle = OpaqueByValueType("CursHandle", "ResObj")
44 45 46 47 48
CCrsrHandle = OpaqueByValueType("CCrsrHandle", "ResObj")
CIconHandle = OpaqueByValueType("CIconHandle", "ResObj")
CTabHandle = OpaqueByValueType("CTabHandle", "ResObj")
ITabHandle = OpaqueByValueType("ITabHandle", "ResObj")
GDHandle = OpaqueByValueType("GDHandle", "ResObj")
49 50
CGrafPtr = OpaqueByValueType("CGrafPtr", "GrafObj")
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 55
RGBColor = OpaqueType('RGBColor', 'QdRGB')
RGBColor_ptr = RGBColor
Jack Jansen's avatar
Jack Jansen committed
56
FontInfo = OpaqueType('FontInfo', 'QdFI')
57 58
Component = OpaqueByValueType('Component', 'CmpObj')
ComponentInstance = OpaqueByValueType('ComponentInstance', 'CmpInstObj')
59

60
Cursor = StructOutputBufferType('Cursor')
61 62 63 64 65
Cursor_ptr = StructInputBufferType('Cursor')
Pattern = StructOutputBufferType('Pattern')
Pattern_ptr = StructInputBufferType('Pattern')
PenState = StructOutputBufferType('PenState')
PenState_ptr = StructInputBufferType('PenState')
66
TruncCode = Type("TruncCode", "h")
67

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

71 72 73 74 75 76
#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);
77
extern int _QdRGB_Convert(PyObject *, RGBColorPtr);
78 79 80 81 82 83 84 85 86

#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

Jack Jansen's avatar
Jack Jansen committed
87
static PyObject *BMObj_NewCopied(BitMapPtr);
88

89 90 91
/*
** Parse/generate RGB records
*/
92
PyObject *QdRGB_New(RGBColorPtr itself)
93 94 95 96 97
{

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

98
int QdRGB_Convert(PyObject *v, RGBColorPtr p_itself)
99 100 101 102 103 104 105 106 107 108 109
{
	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;
}

Jack Jansen's avatar
Jack Jansen committed
110 111 112 113
/*
** Generate FontInfo records
*/
static
114
PyObject *QdFI_New(FontInfo *itself)
Jack Jansen's avatar
Jack Jansen committed
115 116 117 118 119
{

	return Py_BuildValue("hhhh", itself->ascent, itself->descent,
			itself->widMax, itself->leading);
}
120
"""
Jack Jansen's avatar
Jack Jansen committed
121

122 123 124 125
finalstuff = finalstuff + """
/* Like BMObj_New, but the original bitmap data structure is copied (and
** released when the object is released)
*/
126
PyObject *BMObj_NewCopied(BitMapPtr itself)
127 128 129 130 131 132 133 134 135 136 137
{
	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;
}
Jack Jansen's avatar
Jack Jansen committed
138

139
"""
140

141
variablestuff = ""
142

143
initstuff = initstuff + """
144 145 146 147 148
	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);
149
	PyMac_INIT_TOOLBOX_OBJECT_CONVERT(RGBColor, QdRGB_Convert);
150 151
"""

152 153 154 155 156 157 158 159 160 161 162 163 164 165
## 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)

166
class MyGRObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
	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"
		)]
182 183 184
	def outputCheckNewArg(self):
		Output("if (itself == NULL) return PyMac_Error(resNotFound);")
	def outputCheckConvertArg(self):
185 186 187 188 189 190 191 192 193 194
		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")
195 196 197 198 199 200 201 202
		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);")
203 204
		Output("return 1;")
		OutRbrace()
205
		Output("#endif")
206

207
class MyBMObjectDefinition(PEP253Mixin, GlobalObjectDefinition):
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
	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
	)]
235 236 237 238 239 240 241 242 243 244 245 246 247 248
	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);")
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 254 255 256 257 258
##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)
259 260
bm_object = MyBMObjectDefinition("BitMap", "BMObj", "BitMapPtr")
module.addobject(bm_object)
261

262 263

# Create the generator classes used to populate the lists
264 265
Function = OSErrWeakLinkFunctionGenerator
Method = OSErrWeakLinkMethodGenerator
266 267 268

# Create and populate the lists
functions = []
269 270 271
gr_methods = []
bm_methods = []
#methods = []
272
execfile(INPUTFILE)
273
execfile(EXTRAFILE)
274 275 276 277

# 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)
278 279
for f in gr_methods: gr_object.add(f)
for f in bm_methods: bm_object.add(f)
280

281 282 283 284 285 286 287 288
# 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;
289 290
_res = PyString_FromStringAndSize(cp, length);
return _res;
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
"""
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);
306 307
_res = Py_None;
return _res;
308 309 310 311 312
"""
f = ManualGenerator("putdata", putdata_body)
f.docstring = lambda: """(int start, string data). Store bytes into the bitmap"""
bm_object.add(f)

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
#
# 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)

346 347 348 349 350 351 352 353 354 355
#
# 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) ) {
356 357 358
	PyErr_Format(PyExc_TypeError, 
		"Argument size was %d, should be %d (sizeof BitMap) or %d (sizeof PixMap)", 
		PyString_Size(source), sizeof(BitMap), sizeof(PixMap));
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
	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)

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