Import Upstream version 2.7.18
This commit is contained in:
geos_one
3410
Mac/Modules/file/_Filemodule.c
Normal file
3410
Mac/Modules/file/_Filemodule.c
Normal file
File diff suppressed because it is too large
Load Diff
198
Mac/Modules/file/filescan.py
Normal file
198
Mac/Modules/file/filescan.py
Normal file
@@ -0,0 +1,198 @@
|
||||
# Scan an Apple header file, generating a Python file of generator calls.
|
||||
|
||||
import sys
|
||||
from bgenlocations import TOOLBOXDIR, BGENDIR
|
||||
sys.path.append(BGENDIR)
|
||||
from scantools import Scanner_OSX
|
||||
|
||||
LONG = "Files"
|
||||
SHORT = "file"
|
||||
|
||||
def main():
|
||||
input = ["Files.h", "Aliases.h", "Finder.h"]
|
||||
output = SHORT + "gen.py"
|
||||
defsoutput = TOOLBOXDIR + LONG + ".py"
|
||||
scanner = MyScanner(input, output, defsoutput)
|
||||
scanner.scan()
|
||||
scanner.close()
|
||||
scanner.gentypetest(SHORT+"typetest.py")
|
||||
print "=== Testing definitions output code ==="
|
||||
execfile(defsoutput, {}, {})
|
||||
print "=== Done scanning and generating, now importing the generated code... ==="
|
||||
exec "import " + SHORT + "support"
|
||||
print "=== Done. It's up to you to compile it now! ==="
|
||||
|
||||
class MyScanner(Scanner_OSX):
|
||||
|
||||
def destination(self, type, name, arglist):
|
||||
classname = "Function"
|
||||
listname = "functions"
|
||||
if arglist:
|
||||
# Funny special case
|
||||
if len(arglist) > 2:
|
||||
t, n, m = arglist[1]
|
||||
if t == "AliasHandle" and m == "InMode":
|
||||
classname = "Arg2MethodGenerator"
|
||||
listname = "alias_methods"
|
||||
return classname, listname
|
||||
# Normal cases
|
||||
t, n, m = arglist[0]
|
||||
if t == "AliasHandle" and m == "InMode":
|
||||
classname = "Method"
|
||||
listname = "alias_methods"
|
||||
if t == "FSSpec_ptr" and m == "InMode":
|
||||
classname = "Method"
|
||||
listname = "fsspec_methods"
|
||||
if t == "FSRef_ptr" and m == "InMode":
|
||||
classname = "Method"
|
||||
listname = "fsref_methods"
|
||||
return classname, listname
|
||||
|
||||
def makeblacklistnames(self):
|
||||
return [
|
||||
# Constants with incompatible definitions
|
||||
"kioACAccessOwnerMask",
|
||||
"kFSCatInfoReserved",
|
||||
"kFSIterateReserved",
|
||||
"kSystemFolderType",
|
||||
|
||||
"FSRefMakePath", # Do this manually
|
||||
# "ResolveAlias", # Do this manually
|
||||
# "ResolveAliasWithMountFlags", # Do this manually
|
||||
# "FollowFinderAlias", # Do this manually
|
||||
|
||||
"FSRead", # Couldn't be bothered
|
||||
"FSWrite", # ditto
|
||||
"FSReadFork", # ditto
|
||||
"FSWriteFork", # ditto
|
||||
|
||||
# Old routines:
|
||||
"GetWDInfo",
|
||||
"OpenWD",
|
||||
"CloseWD",
|
||||
"FInitQueue",
|
||||
"rstflock",
|
||||
"setflock",
|
||||
"setfinfo",
|
||||
"fsrename",
|
||||
"fsdelete",
|
||||
"create",
|
||||
"flushvol",
|
||||
"eject",
|
||||
"umountvol",
|
||||
"setvol",
|
||||
"getvol",
|
||||
"getfinfo",
|
||||
"getvinfo",
|
||||
"fsopen",
|
||||
"RstFLock",
|
||||
"SetFLock",
|
||||
"SetFInfo",
|
||||
"Rename",
|
||||
"OpenRF",
|
||||
"FSDelete",
|
||||
"Create",
|
||||
"GetVol",
|
||||
"GetFInfo",
|
||||
"GetVInfo",
|
||||
"FSOpen",
|
||||
"Eject",
|
||||
"SetVol",
|
||||
"openrf",
|
||||
"unmountvol",
|
||||
"OpenDF",
|
||||
|
||||
]
|
||||
|
||||
def makeblacklisttypes(self):
|
||||
return [
|
||||
"CInfoPBPtr", # Old stuff
|
||||
"CMovePBPtr", # Old stuff
|
||||
"ParmBlkPtr", # Old stuff
|
||||
"HParmBlkPtr", # Old stuff
|
||||
"DTPBPtr", # Old stuff
|
||||
"FCBPBPtr", # Old stuff
|
||||
"QHdrPtr", # Old stuff
|
||||
"CSParamPtr", # Old stuff
|
||||
"FSCatalogBulkParam", # old stuff
|
||||
"FSForkCBInfoParam", # old stuff
|
||||
"FSForkIOParam", # old stuff
|
||||
"FSRefParam", # old stuff
|
||||
"FSVolumeInfoParam", # old stuff
|
||||
"WDPBPtr", # old stuff
|
||||
"XCInfoPBPtr", # old stuff
|
||||
"XVolumeParamPtr", # old stuff
|
||||
|
||||
|
||||
"CatPositionRec", # State variable, not too difficult
|
||||
"FSIterator", # Should become an object
|
||||
"FSForkInfo", # Lots of fields, difficult struct
|
||||
"FSSearchParams", # Also catsearch stuff
|
||||
"FSVolumeInfo", # big struct
|
||||
"FSVolumeInfo_ptr", # big struct
|
||||
|
||||
"IOCompletionProcPtr", # proc pointer
|
||||
"IOCompletionUPP", # Proc pointer
|
||||
"AliasFilterProcPtr",
|
||||
"AliasFilterUPP",
|
||||
"FNSubscriptionUPP",
|
||||
|
||||
"FNSubscriptionRef", # Lazy, for now.
|
||||
]
|
||||
|
||||
def makerepairinstructions(self):
|
||||
return [
|
||||
# Various ways to give pathnames
|
||||
([('char_ptr', '*', 'InMode')],
|
||||
[('stringptr', '*', 'InMode')]
|
||||
),
|
||||
|
||||
# Unicode filenames passed as length, buffer
|
||||
([('UniCharCount', '*', 'InMode'),
|
||||
('UniChar_ptr', '*', 'InMode')],
|
||||
[('UnicodeReverseInBuffer', '*', 'InMode')]
|
||||
),
|
||||
# Wrong guess
|
||||
([('Str63', 'theString', 'InMode')],
|
||||
[('Str63', 'theString', 'OutMode')]),
|
||||
|
||||
# Yet another way to give a pathname:-)
|
||||
([('short', 'fullPathLength', 'InMode'),
|
||||
('void_ptr', 'fullPath', 'InMode')],
|
||||
[('FullPathName', 'fullPath', 'InMode')]),
|
||||
|
||||
# Various ResolveAliasFileXXXX functions
|
||||
([('FSSpec', 'theSpec', 'OutMode')],
|
||||
[('FSSpec_ptr', 'theSpec', 'InOutMode')]),
|
||||
|
||||
([('FSRef', 'theRef', 'OutMode')],
|
||||
[('FSRef_ptr', 'theRef', 'InOutMode')]),
|
||||
|
||||
# The optional FSSpec to all ResolveAlias and NewAlias methods
|
||||
([('FSSpec_ptr', 'fromFile', 'InMode')],
|
||||
[('OptFSSpecPtr', 'fromFile', 'InMode')]),
|
||||
|
||||
([('FSRef_ptr', 'fromFile', 'InMode')],
|
||||
[('OptFSRefPtr', 'fromFile', 'InMode')]),
|
||||
|
||||
## # FSCatalogInfo input handling
|
||||
## ([('FSCatalogInfoBitmap', 'whichInfo', 'InMode'),
|
||||
## ('FSCatalogInfo_ptr', 'catalogInfo', 'InMode')],
|
||||
## [('FSCatalogInfoAndBitmap_in', 'catalogInfo', 'InMode')]),
|
||||
##
|
||||
## # FSCatalogInfo output handling
|
||||
## ([('FSCatalogInfoBitmap', 'whichInfo', 'InMode'),
|
||||
## ('FSCatalogInfo', 'catalogInfo', 'OutMode')],
|
||||
## [('FSCatalogInfoAndBitmap_out', 'catalogInfo', 'InOutMode')]),
|
||||
##
|
||||
|
||||
]
|
||||
|
||||
|
||||
def writeinitialdefs(self):
|
||||
self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n")
|
||||
self.defsfile.write("true = True\n")
|
||||
self.defsfile.write("false = False\n")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
918
Mac/Modules/file/filesupport.py
Normal file
918
Mac/Modules/file/filesupport.py
Normal file
@@ -0,0 +1,918 @@
|
||||
# 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).
|
||||
#
|
||||
# XXXX TO DO:
|
||||
# - Implement correct missing FSSpec handling for Alias methods
|
||||
# - Implement FInfo
|
||||
#
|
||||
# WARNING WARNING WARNING
|
||||
# The file _Filemodule.c was modified manually, don't run this script
|
||||
# unless you really know what you're doing.
|
||||
|
||||
import sys
|
||||
sys.exit(42)
|
||||
|
||||
import string
|
||||
|
||||
# Declarations that change for each manager
|
||||
#MACHEADERFILE = 'Files.h' # The Apple header file
|
||||
MODNAME = '_File' # The name of the module
|
||||
LONGMODNAME = 'Carbon.File' # The "normal" external name of the module
|
||||
|
||||
# The following is *usually* unchanged but may still require tuning
|
||||
MODPREFIX = 'File' # The prefix for module-wide routines
|
||||
INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner
|
||||
OUTPUTFILE = MODNAME + "module.c" # The file generated by this program
|
||||
|
||||
from macsupport import *
|
||||
|
||||
# Various integers:
|
||||
SInt64 = Type("SInt64", "L")
|
||||
UInt64 = Type("UInt64", "L")
|
||||
FNMessage = Type("FNMessage", "l")
|
||||
FSAllocationFlags = Type("FSAllocationFlags", "H")
|
||||
FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")
|
||||
FSIteratorFlags = Type("FSIteratorFlags", "l")
|
||||
FSVolumeRefNum = Type("FSVolumeRefNum", "h")
|
||||
AliasInfoType = Type("AliasInfoType", "h")
|
||||
|
||||
# Various types of strings:
|
||||
#class UniCharCountBuffer(InputOnlyType):
|
||||
# pass
|
||||
class VarReverseInputBufferType(ReverseInputBufferMixin, VarInputBufferType):
|
||||
pass
|
||||
FullPathName = VarReverseInputBufferType()
|
||||
ConstStr31Param = OpaqueArrayType("Str31", "PyMac_BuildStr255", "PyMac_GetStr255")
|
||||
ConstStr32Param = OpaqueArrayType("Str32", "PyMac_BuildStr255", "PyMac_GetStr255")
|
||||
ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
|
||||
Str63 = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")
|
||||
|
||||
HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")
|
||||
UInt8_ptr = InputOnlyType("UInt8 *", "s")
|
||||
|
||||
# Other types:
|
||||
class OptionalFSxxxType(OpaqueByValueType):
|
||||
def declare(self, name):
|
||||
Output("%s %s__buf__;", self.typeName, name)
|
||||
Output("%s *%s = &%s__buf__;", self.typeName, name, name)
|
||||
|
||||
class FSCatalogInfoAndBitmapType(InputOnlyType):
|
||||
|
||||
def __init__(self):
|
||||
InputOnlyType.__init__(self, "BUG", "BUG")
|
||||
|
||||
def declare(self, name):
|
||||
Output("PyObject *%s__object = NULL;", name)
|
||||
Output("FSCatalogInfoBitmap %s__bitmap = 0;", name)
|
||||
Output("FSCatalogInfo %s;", name)
|
||||
|
||||
def getargsFormat(self):
|
||||
return "lO"
|
||||
|
||||
def getargsArgs(self, name):
|
||||
return "%s__bitmap, %s__object"%(name, name)
|
||||
|
||||
def getargsCheck(self, name):
|
||||
Output("if (!convert_FSCatalogInfo(%s__object, %s__bitmap, &%s)) return NULL;", name, name, name)
|
||||
|
||||
def passInput(self, name):
|
||||
return "%s__bitmap, &%s"% (name, name)
|
||||
|
||||
def passOutput(self, name):
|
||||
return "%s__bitmap, &%s"% (name, name)
|
||||
|
||||
def mkvalueFormat(self):
|
||||
return "O"
|
||||
|
||||
def mkvalueArgs(self, name):
|
||||
return "%s__object" % (name)
|
||||
|
||||
def xxxxmkvalueCheck(self, name):
|
||||
Output("if ((%s__object = new_FSCatalogInfo(%s__bitmap, &%s)) == NULL) return NULL;", name, name)
|
||||
|
||||
class FSCatalogInfoAndBitmap_inType(FSCatalogInfoAndBitmapType, InputOnlyMixIn):
|
||||
|
||||
def xxxxmkvalueCheck(self, name):
|
||||
pass
|
||||
|
||||
class FSCatalogInfoAndBitmap_outType(FSCatalogInfoAndBitmapType):
|
||||
|
||||
def getargsFormat(self):
|
||||
return "l"
|
||||
|
||||
def getargsArgs(self, name):
|
||||
return "%s__bitmap" % name
|
||||
|
||||
def getargsCheck(self, name):
|
||||
pass
|
||||
|
||||
FInfo = OpaqueType("FInfo", "FInfo")
|
||||
FInfo_ptr = OpaqueType("FInfo", "FInfo")
|
||||
AliasHandle = OpaqueByValueType("AliasHandle", "Alias")
|
||||
FSSpec = OpaqueType("FSSpec", "FSSpec")
|
||||
FSSpec_ptr = OpaqueType("FSSpec", "FSSpec")
|
||||
OptFSSpecPtr = OptionalFSxxxType("FSSpec", "BUG", "myPyMac_GetOptFSSpecPtr")
|
||||
FSRef = OpaqueType("FSRef", "FSRef")
|
||||
FSRef_ptr = OpaqueType("FSRef", "FSRef")
|
||||
OptFSRefPtr = OptionalFSxxxType("FSRef", "BUG", "myPyMac_GetOptFSRefPtr")
|
||||
FSCatalogInfo = OpaqueType("FSCatalogInfo", "FSCatalogInfo")
|
||||
FSCatalogInfo_ptr = OpaqueType("FSCatalogInfo", "FSCatalogInfo")
|
||||
|
||||
# To be done:
|
||||
#CatPositionRec
|
||||
#FSCatalogInfo
|
||||
#FSForkInfo
|
||||
#FSIterator
|
||||
#FSVolumeInfo
|
||||
#FSSpecArrayPtr
|
||||
|
||||
includestuff = includestuff + """
|
||||
#include <Carbon/Carbon.h>
|
||||
|
||||
#ifdef USE_TOOLBOX_OBJECT_GLUE
|
||||
extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
|
||||
extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);
|
||||
extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);
|
||||
extern PyObject *_PyMac_BuildFSRef(FSRef *spec);
|
||||
|
||||
#define PyMac_GetFSSpec _PyMac_GetFSSpec
|
||||
#define PyMac_GetFSRef _PyMac_GetFSRef
|
||||
#define PyMac_BuildFSSpec _PyMac_BuildFSSpec
|
||||
#define PyMac_BuildFSRef _PyMac_BuildFSRef
|
||||
#else
|
||||
extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);
|
||||
extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);
|
||||
extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);
|
||||
extern PyObject *PyMac_BuildFSRef(FSRef *spec);
|
||||
#endif
|
||||
|
||||
/* Forward declarations */
|
||||
static PyObject *FInfo_New(FInfo *itself);
|
||||
static PyObject *FSRef_New(FSRef *itself);
|
||||
static PyObject *FSSpec_New(FSSpec *itself);
|
||||
static PyObject *Alias_New(AliasHandle itself);
|
||||
static int FInfo_Convert(PyObject *v, FInfo *p_itself);
|
||||
#define FSRef_Convert PyMac_GetFSRef
|
||||
#define FSSpec_Convert PyMac_GetFSSpec
|
||||
static int Alias_Convert(PyObject *v, AliasHandle *p_itself);
|
||||
|
||||
/*
|
||||
** UTCDateTime records
|
||||
*/
|
||||
static int
|
||||
UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)
|
||||
{
|
||||
return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
UTCDateTime_New(UTCDateTime *ptr)
|
||||
{
|
||||
return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction);
|
||||
}
|
||||
|
||||
/*
|
||||
** Optional fsspec and fsref pointers. None will pass NULL
|
||||
*/
|
||||
static int
|
||||
myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec)
|
||||
{
|
||||
if (v == Py_None) {
|
||||
*spec = NULL;
|
||||
return 1;
|
||||
}
|
||||
return PyMac_GetFSSpec(v, *spec);
|
||||
}
|
||||
|
||||
static int
|
||||
myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref)
|
||||
{
|
||||
if (v == Py_None) {
|
||||
*ref = NULL;
|
||||
return 1;
|
||||
}
|
||||
return PyMac_GetFSRef(v, *ref);
|
||||
}
|
||||
|
||||
/*
|
||||
** Parse/generate objsect
|
||||
*/
|
||||
static PyObject *
|
||||
PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)
|
||||
{
|
||||
|
||||
return Py_BuildValue("u#", itself->unicode, itself->length);
|
||||
}
|
||||
|
||||
#ifndef __LP64__
|
||||
/*
|
||||
** Get pathname for a given FSSpec
|
||||
*/
|
||||
static OSErr
|
||||
_PyMac_GetFullPathname(FSSpec *fss, char *path, int len)
|
||||
{
|
||||
FSRef fsr;
|
||||
OSErr err;
|
||||
|
||||
*path = '\0';
|
||||
err = FSpMakeFSRef(fss, &fsr);
|
||||
if (err == fnfErr) {
|
||||
/* FSSpecs can point to non-existing files, fsrefs can't. */
|
||||
FSSpec fss2;
|
||||
int tocopy;
|
||||
|
||||
err = FSMakeFSSpec(fss->vRefNum, fss->parID, "", &fss2);
|
||||
if (err)
|
||||
return err;
|
||||
err = FSpMakeFSRef(&fss2, &fsr);
|
||||
if (err)
|
||||
return err;
|
||||
err = (OSErr)FSRefMakePath(&fsr, path, len-1);
|
||||
if (err)
|
||||
return err;
|
||||
/* This part is not 100% safe: we append the filename part, but
|
||||
** I'm not sure that we don't run afoul of the various 8bit
|
||||
** encodings here. Will have to look this up at some point...
|
||||
*/
|
||||
strcat(path, "/");
|
||||
tocopy = fss->name[0];
|
||||
if ((strlen(path) + tocopy) >= len)
|
||||
tocopy = len - strlen(path) - 1;
|
||||
if (tocopy > 0)
|
||||
strncat(path, fss->name+1, tocopy);
|
||||
}
|
||||
else {
|
||||
if (err)
|
||||
return err;
|
||||
err = (OSErr)FSRefMakePath(&fsr, path, len);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* !__LP64__ */
|
||||
|
||||
"""
|
||||
|
||||
finalstuff = finalstuff + """
|
||||
|
||||
#ifndef __LP64__
|
||||
int
|
||||
PyMac_GetFSSpec(PyObject *v, FSSpec *spec)
|
||||
{
|
||||
Str255 path;
|
||||
short refnum;
|
||||
long parid;
|
||||
OSErr err;
|
||||
FSRef fsr;
|
||||
|
||||
if (FSSpec_Check(v)) {
|
||||
*spec = ((FSSpecObject *)v)->ob_itself;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (PyArg_Parse(v, "(hlO&)",
|
||||
&refnum, &parid, PyMac_GetStr255, &path)) {
|
||||
err = FSMakeFSSpec(refnum, parid, path, spec);
|
||||
if ( err && err != fnfErr ) {
|
||||
PyMac_Error(err);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
PyErr_Clear();
|
||||
/* Otherwise we try to go via an FSRef. On OSX we go all the way,
|
||||
** on OS9 we accept only a real FSRef object
|
||||
*/
|
||||
if ( PyMac_GetFSRef(v, &fsr) ) {
|
||||
err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);
|
||||
if (err != noErr) {
|
||||
PyMac_Error(err);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* !__LP64__ */
|
||||
|
||||
int
|
||||
PyMac_GetFSRef(PyObject *v, FSRef *fsr)
|
||||
{
|
||||
OSStatus err;
|
||||
FSSpec fss;
|
||||
|
||||
if (FSRef_Check(v)) {
|
||||
*fsr = ((FSRefObject *)v)->ob_itself;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* On OSX we now try a pathname */
|
||||
if ( PyString_Check(v) || PyUnicode_Check(v)) {
|
||||
char *path = NULL;
|
||||
if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))
|
||||
return 0;
|
||||
if ( (err=FSPathMakeRef(path, fsr, NULL)) )
|
||||
PyMac_Error(err);
|
||||
PyMem_Free(path);
|
||||
return !err;
|
||||
}
|
||||
/* XXXX Should try unicode here too */
|
||||
/* Otherwise we try to go via an FSSpec */
|
||||
#ifndef __LP64__
|
||||
if (FSSpec_Check(v)) {
|
||||
fss = ((FSSpecObject *)v)->ob_itself;
|
||||
if ((err=FSpMakeFSRef(&fss, fsr)) == 0)
|
||||
return 1;
|
||||
PyMac_Error(err);
|
||||
return 0;
|
||||
}
|
||||
PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");
|
||||
#else /* __LP64__ */
|
||||
PyErr_SetString(PyExc_TypeError, "FSRef or pathname required");
|
||||
#endif /* __LP64__ */
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifndef __LP64__
|
||||
extern PyObject *
|
||||
PyMac_BuildFSSpec(FSSpec *spec)
|
||||
{
|
||||
return FSSpec_New(spec);
|
||||
}
|
||||
#endif /* __LP64__ */
|
||||
|
||||
extern PyObject *
|
||||
PyMac_BuildFSRef(FSRef *spec)
|
||||
{
|
||||
return FSRef_New(spec);
|
||||
}
|
||||
"""
|
||||
|
||||
initstuff = initstuff + """
|
||||
#ifndef __LP64__
|
||||
PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec);
|
||||
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec);
|
||||
#endif /* !__LP64__*/
|
||||
PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef);
|
||||
PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef);
|
||||
"""
|
||||
|
||||
execfile(string.lower(MODPREFIX) + 'typetest.py')
|
||||
|
||||
# Our object types:
|
||||
class FSCatalogInfoDefinition(PEP253Mixin, ObjectDefinition):
|
||||
getsetlist = [
|
||||
("nodeFlags",
|
||||
"return Py_BuildValue(\"H\", self->ob_itself.nodeFlags);",
|
||||
"return PyArg_Parse(v, \"H\", &self->ob_itself.nodeFlags)-1;",
|
||||
None
|
||||
),
|
||||
("volume",
|
||||
"return Py_BuildValue(\"h\", self->ob_itself.volume);",
|
||||
"return PyArg_Parse(v, \"h\", &self->ob_itself.volume)-1;",
|
||||
None
|
||||
),
|
||||
("parentDirID",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.parentDirID);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.parentDirID)-1;",
|
||||
None
|
||||
),
|
||||
("nodeID",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.nodeID);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.nodeID)-1;",
|
||||
None
|
||||
),
|
||||
("createDate",
|
||||
"return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.createDate);",
|
||||
"return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.createDate)-1;",
|
||||
None
|
||||
),
|
||||
("contentModDate",
|
||||
"return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.contentModDate);",
|
||||
"return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1;",
|
||||
None
|
||||
),
|
||||
("attributeModDate",
|
||||
"return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.attributeModDate);",
|
||||
"return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1;",
|
||||
None
|
||||
),
|
||||
("accessDate",
|
||||
"return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.accessDate);",
|
||||
"return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.accessDate)-1;",
|
||||
None
|
||||
),
|
||||
("backupDate",
|
||||
"return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.backupDate);",
|
||||
"return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.backupDate)-1;",
|
||||
None
|
||||
),
|
||||
("permissions",
|
||||
"return Py_BuildValue(\"(llll)\", self->ob_itself.permissions[0], self->ob_itself.permissions[1], self->ob_itself.permissions[2], self->ob_itself.permissions[3]);",
|
||||
"return PyArg_Parse(v, \"(llll)\", &self->ob_itself.permissions[0], &self->ob_itself.permissions[1], &self->ob_itself.permissions[2], &self->ob_itself.permissions[3])-1;",
|
||||
None
|
||||
),
|
||||
# XXXX FinderInfo TBD
|
||||
# XXXX FinderXInfo TBD
|
||||
("valence",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.valence);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.valence)-1;",
|
||||
None
|
||||
),
|
||||
("dataLogicalSize",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.dataLogicalSize);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.dataLogicalSize)-1;",
|
||||
None
|
||||
),
|
||||
("dataPhysicalSize",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.dataPhysicalSize);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.dataPhysicalSize)-1;",
|
||||
None
|
||||
),
|
||||
("rsrcLogicalSize",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.rsrcLogicalSize);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcLogicalSize)-1;",
|
||||
None
|
||||
),
|
||||
("rsrcPhysicalSize",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.rsrcPhysicalSize);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcPhysicalSize)-1;",
|
||||
None
|
||||
),
|
||||
("sharingFlags",
|
||||
"return Py_BuildValue(\"l\", self->ob_itself.sharingFlags);",
|
||||
"return PyArg_Parse(v, \"l\", &self->ob_itself.sharingFlags)-1;",
|
||||
None
|
||||
),
|
||||
("userPrivileges",
|
||||
"return Py_BuildValue(\"b\", self->ob_itself.userPrivileges);",
|
||||
"return PyArg_Parse(v, \"b\", &self->ob_itself.userPrivileges)-1;",
|
||||
None
|
||||
),
|
||||
]
|
||||
# The same info, but in a different form
|
||||
INITFORMAT = "HhllO&O&O&O&O&llllllb"
|
||||
INITARGS = """&((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.volume,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.parentDirID,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.nodeID,
|
||||
UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate,
|
||||
UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate,
|
||||
UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate,
|
||||
UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate,
|
||||
UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.valence,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags,
|
||||
&((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges"""
|
||||
INITNAMES = """
|
||||
"nodeFlags",
|
||||
"volume",
|
||||
"parentDirID",
|
||||
"nodeID",
|
||||
"createDate",
|
||||
"contentModDate",
|
||||
"atributeModDate",
|
||||
"accessDate",
|
||||
"backupDate",
|
||||
"valence",
|
||||
"dataLogicalSize",
|
||||
"dataPhysicalSize",
|
||||
"rsrcLogicalSize",
|
||||
"rsrcPhysicalSize",
|
||||
"sharingFlags",
|
||||
"userPrivileges"
|
||||
"""
|
||||
|
||||
def __init__(self, name, prefix, itselftype):
|
||||
ObjectDefinition.__init__(self, name, prefix, itselftype)
|
||||
self.argref = "*" # Store FSSpecs, but pass them by address
|
||||
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }")
|
||||
|
||||
def output_tp_newBody(self):
|
||||
Output("PyObject *self;");
|
||||
Output()
|
||||
Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
|
||||
Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
|
||||
self.objecttype, self.itselftype)
|
||||
Output("return self;")
|
||||
|
||||
def output_tp_initBody(self):
|
||||
Output("static char *kw[] = {%s, 0};", self.INITNAMES)
|
||||
Output()
|
||||
Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|%s\", kw, %s))",
|
||||
self.INITFORMAT, self.INITARGS)
|
||||
OutLbrace()
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("return 0;")
|
||||
|
||||
class FInfoDefinition(PEP253Mixin, ObjectDefinition):
|
||||
getsetlist = [
|
||||
("Type",
|
||||
"return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdType);",
|
||||
"return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdType)-1;",
|
||||
"4-char file type"
|
||||
),
|
||||
("Creator",
|
||||
"return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdCreator);",
|
||||
"return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdCreator)-1;",
|
||||
"4-char file creator"
|
||||
),
|
||||
("Flags",
|
||||
"return Py_BuildValue(\"H\", self->ob_itself.fdFlags);",
|
||||
"return PyArg_Parse(v, \"H\", &self->ob_itself.fdFlags)-1;",
|
||||
"Finder flag bits"
|
||||
),
|
||||
("Location",
|
||||
"return Py_BuildValue(\"O&\", PyMac_BuildPoint, self->ob_itself.fdLocation);",
|
||||
"return PyArg_Parse(v, \"O&\", PyMac_GetPoint, &self->ob_itself.fdLocation)-1;",
|
||||
"(x, y) location of the file's icon in its parent finder window"
|
||||
),
|
||||
("Fldr",
|
||||
"return Py_BuildValue(\"h\", self->ob_itself.fdFldr);",
|
||||
"return PyArg_Parse(v, \"h\", &self->ob_itself.fdFldr)-1;",
|
||||
"Original folder, for 'put away'"
|
||||
),
|
||||
|
||||
]
|
||||
|
||||
def __init__(self, name, prefix, itselftype):
|
||||
ObjectDefinition.__init__(self, name, prefix, itselftype)
|
||||
self.argref = "*" # Store FSSpecs, but pass them by address
|
||||
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
|
||||
|
||||
def output_tp_newBody(self):
|
||||
Output("PyObject *self;");
|
||||
Output()
|
||||
Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
|
||||
Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
|
||||
self.objecttype, self.itselftype)
|
||||
Output("return self;")
|
||||
|
||||
def output_tp_initBody(self):
|
||||
Output("%s *itself = NULL;", self.itselftype)
|
||||
Output("static char *kw[] = {\"itself\", 0};")
|
||||
Output()
|
||||
Output("if (PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&\", kw, FInfo_Convert, &itself))")
|
||||
OutLbrace()
|
||||
Output("if (itself) memcpy(&((%s *)_self)->ob_itself, itself, sizeof(%s));",
|
||||
self.objecttype, self.itselftype)
|
||||
Output("return 0;")
|
||||
OutRbrace()
|
||||
Output("return -1;")
|
||||
|
||||
class FSSpecDefinition(PEP253Mixin, ObjectDefinition):
|
||||
getsetlist = [
|
||||
("data",
|
||||
"return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",
|
||||
None,
|
||||
"Raw data of the FSSpec object"
|
||||
)
|
||||
]
|
||||
|
||||
def __init__(self, name, prefix, itselftype):
|
||||
ObjectDefinition.__init__(self, name, prefix, itselftype)
|
||||
self.argref = "*" # Store FSSpecs, but pass them by address
|
||||
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
|
||||
|
||||
# We do Convert ourselves (with PyMac_GetFSxxx)
|
||||
def outputConvert(self):
|
||||
pass
|
||||
|
||||
def output_tp_newBody(self):
|
||||
Output("PyObject *self;");
|
||||
Output()
|
||||
Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
|
||||
Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
|
||||
self.objecttype, self.itselftype)
|
||||
Output("return self;")
|
||||
|
||||
def output_tp_initBody(self):
|
||||
Output("PyObject *v = NULL;")
|
||||
Output("char *rawdata = NULL;")
|
||||
Output("int rawdatalen = 0;")
|
||||
Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
|
||||
Output()
|
||||
Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")
|
||||
Output("return -1;")
|
||||
Output("if (v && rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (!v && !rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (rawdata)")
|
||||
OutLbrace()
|
||||
Output("if (rawdatalen != sizeof(%s))", self.itselftype)
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",
|
||||
self.itselftype)
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)
|
||||
Output("return 0;")
|
||||
OutRbrace()
|
||||
Output("if (PyMac_GetFSSpec(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)
|
||||
Output("return -1;")
|
||||
|
||||
def outputRepr(self):
|
||||
Output()
|
||||
Output("static PyObject * %s_repr(%s *self)", self.prefix, self.objecttype)
|
||||
OutLbrace()
|
||||
Output("char buf[512];")
|
||||
Output("""PyOS_snprintf(buf, sizeof(buf), \"%%s((%%d, %%ld, '%%.*s'))\",
|
||||
self->ob_type->tp_name,
|
||||
self->ob_itself.vRefNum,
|
||||
self->ob_itself.parID,
|
||||
self->ob_itself.name[0], self->ob_itself.name+1);""")
|
||||
Output("return PyString_FromString(buf);")
|
||||
OutRbrace()
|
||||
|
||||
class FSRefDefinition(PEP253Mixin, ObjectDefinition):
|
||||
getsetlist = [
|
||||
("data",
|
||||
"return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",
|
||||
None,
|
||||
"Raw data of the FSRef object"
|
||||
)
|
||||
]
|
||||
|
||||
def __init__(self, name, prefix, itselftype):
|
||||
ObjectDefinition.__init__(self, name, prefix, itselftype)
|
||||
self.argref = "*" # Store FSRefs, but pass them by address
|
||||
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
|
||||
|
||||
# We do Convert ourselves (with PyMac_GetFSxxx)
|
||||
def outputConvert(self):
|
||||
pass
|
||||
|
||||
def output_tp_newBody(self):
|
||||
Output("PyObject *self;");
|
||||
Output()
|
||||
Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
|
||||
Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",
|
||||
self.objecttype, self.itselftype)
|
||||
Output("return self;")
|
||||
|
||||
def output_tp_initBody(self):
|
||||
Output("PyObject *v = NULL;")
|
||||
Output("char *rawdata = NULL;")
|
||||
Output("int rawdatalen = 0;")
|
||||
Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
|
||||
Output()
|
||||
Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")
|
||||
Output("return -1;")
|
||||
Output("if (v && rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (!v && !rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (rawdata)")
|
||||
OutLbrace()
|
||||
Output("if (rawdatalen != sizeof(%s))", self.itselftype)
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",
|
||||
self.itselftype)
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)
|
||||
Output("return 0;")
|
||||
OutRbrace()
|
||||
Output("if (PyMac_GetFSRef(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)
|
||||
Output("return -1;")
|
||||
|
||||
class AliasDefinition(PEP253Mixin, ObjectDefinition):
|
||||
# XXXX Should inherit from resource?
|
||||
getsetlist = [
|
||||
("data",
|
||||
"""int size;
|
||||
PyObject *rv;
|
||||
|
||||
size = GetHandleSize((Handle)self->ob_itself);
|
||||
HLock((Handle)self->ob_itself);
|
||||
rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);
|
||||
HUnlock((Handle)self->ob_itself);
|
||||
return rv;
|
||||
""",
|
||||
None,
|
||||
"Raw data of the alias object"
|
||||
)
|
||||
]
|
||||
|
||||
def outputCheckNewArg(self):
|
||||
Output("if (itself == NULL) return PyMac_Error(resNotFound);")
|
||||
|
||||
def outputStructMembers(self):
|
||||
ObjectDefinition.outputStructMembers(self)
|
||||
Output("void (*ob_freeit)(%s ptr);", self.itselftype)
|
||||
|
||||
def outputInitStructMembers(self):
|
||||
ObjectDefinition.outputInitStructMembers(self)
|
||||
Output("it->ob_freeit = NULL;")
|
||||
|
||||
def outputCleanupStructMembers(self):
|
||||
Output("if (self->ob_freeit && self->ob_itself)")
|
||||
OutLbrace()
|
||||
Output("self->ob_freeit(self->ob_itself);")
|
||||
OutRbrace()
|
||||
Output("self->ob_itself = NULL;")
|
||||
|
||||
def output_tp_newBody(self):
|
||||
Output("PyObject *self;");
|
||||
Output()
|
||||
Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
|
||||
Output("((%s *)self)->ob_itself = NULL;", self.objecttype)
|
||||
Output("return self;")
|
||||
|
||||
def output_tp_initBody(self):
|
||||
Output("%s itself = NULL;", self.itselftype)
|
||||
Output("char *rawdata = NULL;")
|
||||
Output("int rawdatalen = 0;")
|
||||
Output("Handle h;")
|
||||
Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")
|
||||
Output()
|
||||
Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&s#\", kw, %s_Convert, &itself, &rawdata, &rawdatalen))",
|
||||
self.prefix)
|
||||
Output("return -1;")
|
||||
Output("if (itself && rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (!itself && !rawdata)")
|
||||
OutLbrace()
|
||||
Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("if (rawdata)")
|
||||
OutLbrace()
|
||||
Output("if ((h = NewHandle(rawdatalen)) == NULL)")
|
||||
OutLbrace()
|
||||
Output("PyErr_NoMemory();")
|
||||
Output("return -1;")
|
||||
OutRbrace()
|
||||
Output("HLock(h);")
|
||||
Output("memcpy((char *)*h, rawdata, rawdatalen);")
|
||||
Output("HUnlock(h);")
|
||||
Output("((%s *)_self)->ob_itself = (%s)h;", self.objecttype, self.itselftype)
|
||||
Output("return 0;")
|
||||
OutRbrace()
|
||||
Output("((%s *)_self)->ob_itself = itself;", self.objecttype)
|
||||
Output("return 0;")
|
||||
|
||||
# Alias methods come in two flavors: those with the alias as arg1 and
|
||||
# those with the alias as arg 2.
|
||||
class Arg2MethodGenerator(OSErrMethodGenerator):
|
||||
"""Similar to MethodGenerator, but has self as second argument"""
|
||||
|
||||
def parseArgumentList(self, args):
|
||||
args0, arg1, argsrest = args[:1], args[1], args[2:]
|
||||
t0, n0, m0 = arg1
|
||||
args = args0 + argsrest
|
||||
if m0 != InMode:
|
||||
raise ValueError, "method's 'self' must be 'InMode'"
|
||||
self.itself = Variable(t0, "_self->ob_itself", SelfMode)
|
||||
FunctionGenerator.parseArgumentList(self, args)
|
||||
self.argumentList.insert(2, self.itself)
|
||||
|
||||
# From here on it's basically all boiler plate...
|
||||
|
||||
# Create the generator groups and link them
|
||||
module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff,
|
||||
longname=LONGMODNAME)
|
||||
|
||||
fscataloginfoobject = FSCatalogInfoDefinition('FSCatalogInfo', 'FSCatalogInfo', 'FSCatalogInfo')
|
||||
finfoobject = FInfoDefinition('FInfo', 'FInfo', 'FInfo')
|
||||
aliasobject = AliasDefinition('Alias', 'Alias', 'AliasHandle')
|
||||
fsspecobject = FSSpecDefinition('FSSpec', 'FSSpec', 'FSSpec')
|
||||
fsrefobject = FSRefDefinition('FSRef', 'FSRef', 'FSRef')
|
||||
|
||||
module.addobject(fscataloginfoobject)
|
||||
module.addobject(finfoobject)
|
||||
module.addobject(aliasobject)
|
||||
module.addobject(fsspecobject)
|
||||
module.addobject(fsrefobject)
|
||||
|
||||
# Create the generator classes used to populate the lists
|
||||
Function = OSErrFunctionGenerator
|
||||
Method = OSErrMethodGenerator
|
||||
|
||||
# Create and populate the lists
|
||||
functions = []
|
||||
alias_methods = []
|
||||
fsref_methods = []
|
||||
fsspec_methods = []
|
||||
execfile(INPUTFILE)
|
||||
|
||||
# Manual generators:
|
||||
FSRefMakePath_body = """
|
||||
OSStatus _err;
|
||||
#define MAXPATHNAME 1024
|
||||
UInt8 path[MAXPATHNAME];
|
||||
UInt32 maxPathSize = MAXPATHNAME;
|
||||
|
||||
if (!PyArg_ParseTuple(_args, ""))
|
||||
return NULL;
|
||||
_err = FSRefMakePath(&_self->ob_itself,
|
||||
path,
|
||||
maxPathSize);
|
||||
if (_err != noErr) return PyMac_Error(_err);
|
||||
_res = Py_BuildValue("s", path);
|
||||
return _res;
|
||||
"""
|
||||
f = ManualGenerator("FSRefMakePath", FSRefMakePath_body)
|
||||
f.docstring = lambda: "() -> string"
|
||||
fsref_methods.append(f)
|
||||
|
||||
FSRef_as_pathname_body = """
|
||||
if (!PyArg_ParseTuple(_args, ""))
|
||||
return NULL;
|
||||
_res = FSRef_FSRefMakePath(_self, _args);
|
||||
return _res;
|
||||
"""
|
||||
f = ManualGenerator("as_pathname", FSRef_as_pathname_body)
|
||||
f.docstring = lambda: "() -> string"
|
||||
fsref_methods.append(f)
|
||||
|
||||
FSSpec_as_pathname_body = """
|
||||
char strbuf[1024];
|
||||
OSErr err;
|
||||
|
||||
if (!PyArg_ParseTuple(_args, ""))
|
||||
return NULL;
|
||||
err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf));
|
||||
if ( err ) {
|
||||
PyMac_Error(err);
|
||||
return NULL;
|
||||
}
|
||||
_res = PyString_FromString(strbuf);
|
||||
return _res;
|
||||
"""
|
||||
f = ManualGenerator("as_pathname", FSSpec_as_pathname_body)
|
||||
f.docstring = lambda: "() -> string"
|
||||
fsspec_methods.append(f)
|
||||
|
||||
FSSpec_as_tuple_body = """
|
||||
if (!PyArg_ParseTuple(_args, ""))
|
||||
return NULL;
|
||||
_res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID,
|
||||
&_self->ob_itself.name[1], _self->ob_itself.name[0]);
|
||||
return _res;
|
||||
"""
|
||||
f = ManualGenerator("as_tuple", FSSpec_as_tuple_body)
|
||||
f.docstring = lambda: "() -> (vRefNum, dirID, name)"
|
||||
fsspec_methods.append(f)
|
||||
|
||||
pathname_body = """
|
||||
PyObject *obj;
|
||||
|
||||
if (!PyArg_ParseTuple(_args, "O", &obj))
|
||||
return NULL;
|
||||
if (PyString_Check(obj)) {
|
||||
Py_INCREF(obj);
|
||||
return obj;
|
||||
}
|
||||
if (PyUnicode_Check(obj))
|
||||
return PyUnicode_AsEncodedString(obj, "utf8", "strict");
|
||||
_res = PyObject_CallMethod(obj, "as_pathname", NULL);
|
||||
return _res;
|
||||
"""
|
||||
f = ManualGenerator("pathname", pathname_body)
|
||||
f.docstring = lambda: "(str|unicode|FSSpec|FSref) -> pathname"
|
||||
functions.append(f)
|
||||
|
||||
# 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 alias_methods: aliasobject.add(f)
|
||||
for f in fsspec_methods: fsspecobject.add(f)
|
||||
for f in fsref_methods: fsrefobject.add(f)
|
||||
|
||||
# generate output (open the output file as late as possible)
|
||||
SetOutputFileName(OUTPUTFILE)
|
||||
module.generate()
|
||||
Reference in New Issue
Block a user