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 # XXXX TO DO:

     7 # - Implement correct missing FSSpec handling for Alias methods

     8 # - Implement FInfo

     9 #

    10 # WARNING WARNING WARNING

    11 #   The file _Filemodule.c was modified manually, don't run this script

    12 #   unless you really know what you're doing.

    13 

    14 import sys

    15 sys.exit(42)

    16 

    17 import string

    18 

    19 # Declarations that change for each manager

    20 #MACHEADERFILE = 'Files.h'              # The Apple header file

    21 MODNAME = '_File'                               # The name of the module

    22 LONGMODNAME = 'Carbon.File'             # The "normal" external name of the module

    23 

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

    25 MODPREFIX = 'File'                      # The prefix for module-wide routines

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

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

    28 

    29 from macsupport import *

    30 

    31 # Various integers:

    32 SInt64 = Type("SInt64", "L")

    33 UInt64 = Type("UInt64", "L")

    34 FNMessage = Type("FNMessage", "l")

    35 FSAllocationFlags = Type("FSAllocationFlags", "H")

    36 FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l")

    37 FSIteratorFlags = Type("FSIteratorFlags", "l")

    38 FSVolumeRefNum = Type("FSVolumeRefNum", "h")

    39 AliasInfoType = Type("AliasInfoType", "h")

    40 

    41 # Various types of strings:

    42 #class UniCharCountBuffer(InputOnlyType):

    43 #       pass

    44 class VarReverseInputBufferType(ReverseInputBufferMixin, VarInputBufferType):

    45     pass

    46 FullPathName = VarReverseInputBufferType()

    47 ConstStr31Param = OpaqueArrayType("Str31", "PyMac_BuildStr255", "PyMac_GetStr255")

    48 ConstStr32Param = OpaqueArrayType("Str32", "PyMac_BuildStr255", "PyMac_GetStr255")

    49 ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")

    50 Str63 = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255")

    51 

    52 HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255")

    53 UInt8_ptr = InputOnlyType("UInt8 *", "s")

    54 

    55 # Other types:

    56 class OptionalFSxxxType(OpaqueByValueType):

    57     def declare(self, name):

    58         Output("%s %s__buf__;", self.typeName, name)

    59         Output("%s *%s = &%s__buf__;", self.typeName, name, name)

    60 

    61 class FSCatalogInfoAndBitmapType(InputOnlyType):

    62 

    63     def __init__(self):

    64         InputOnlyType.__init__(self, "BUG", "BUG")

    65 

    66     def declare(self, name):

    67         Output("PyObject *%s__object = NULL;", name)

    68         Output("FSCatalogInfoBitmap %s__bitmap = 0;", name)

    69         Output("FSCatalogInfo %s;", name)

    70 

    71     def getargsFormat(self):

    72         return "lO"

    73 

    74     def getargsArgs(self, name):

    75         return "%s__bitmap, %s__object"%(name, name)

    76 

    77     def getargsCheck(self, name):

    78         Output("if (!convert_FSCatalogInfo(%s__object, %s__bitmap, &%s)) return NULL;", name, name, name)

    79 

    80     def passInput(self, name):

    81         return "%s__bitmap, &%s"% (name, name)

    82 

    83     def passOutput(self, name):

    84         return "%s__bitmap, &%s"% (name, name)

    85 

    86     def mkvalueFormat(self):

    87         return "O"

    88 

    89     def mkvalueArgs(self, name):

    90         return "%s__object" % (name)

    91 

    92     def xxxxmkvalueCheck(self, name):

    93         Output("if ((%s__object = new_FSCatalogInfo(%s__bitmap, &%s)) == NULL) return NULL;", name, name)

    94 

    95 class FSCatalogInfoAndBitmap_inType(FSCatalogInfoAndBitmapType, InputOnlyMixIn):

    96 

    97     def xxxxmkvalueCheck(self, name):

    98         pass

    99 

   100 class FSCatalogInfoAndBitmap_outType(FSCatalogInfoAndBitmapType):

   101 

   102     def getargsFormat(self):

   103         return "l"

   104 

   105     def getargsArgs(self, name):

   106         return "%s__bitmap" % name

   107 

   108     def getargsCheck(self, name):

   109         pass

   110 

   111 FInfo = OpaqueType("FInfo", "FInfo")

   112 FInfo_ptr = OpaqueType("FInfo", "FInfo")

   113 AliasHandle = OpaqueByValueType("AliasHandle", "Alias")

   114 FSSpec = OpaqueType("FSSpec", "FSSpec")

   115 FSSpec_ptr = OpaqueType("FSSpec", "FSSpec")

   116 OptFSSpecPtr = OptionalFSxxxType("FSSpec", "BUG", "myPyMac_GetOptFSSpecPtr")

   117 FSRef = OpaqueType("FSRef", "FSRef")

   118 FSRef_ptr = OpaqueType("FSRef", "FSRef")

   119 OptFSRefPtr = OptionalFSxxxType("FSRef", "BUG", "myPyMac_GetOptFSRefPtr")

   120 FSCatalogInfo = OpaqueType("FSCatalogInfo", "FSCatalogInfo")

   121 FSCatalogInfo_ptr = OpaqueType("FSCatalogInfo", "FSCatalogInfo")

   122 

   123 # To be done:

   124 #CatPositionRec

   125 #FSCatalogInfo

   126 #FSForkInfo

   127 #FSIterator

   128 #FSVolumeInfo

   129 #FSSpecArrayPtr

   130 

   131 includestuff = includestuff + """

   132 #include <Carbon/Carbon.h>

   133 

   134 #ifdef USE_TOOLBOX_OBJECT_GLUE

   135 extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec);

   136 extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr);

   137 extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec);

   138 extern PyObject *_PyMac_BuildFSRef(FSRef *spec);

   139 

   140 #define PyMac_GetFSSpec _PyMac_GetFSSpec

   141 #define PyMac_GetFSRef _PyMac_GetFSRef

   142 #define PyMac_BuildFSSpec _PyMac_BuildFSSpec

   143 #define PyMac_BuildFSRef _PyMac_BuildFSRef

   144 #else

   145 extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec);

   146 extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr);

   147 extern PyObject *PyMac_BuildFSSpec(FSSpec *spec);

   148 extern PyObject *PyMac_BuildFSRef(FSRef *spec);

   149 #endif

   150 

   151 /* Forward declarations */

   152 static PyObject *FInfo_New(FInfo *itself);

   153 static PyObject *FSRef_New(FSRef *itself);

   154 static PyObject *FSSpec_New(FSSpec *itself);

   155 static PyObject *Alias_New(AliasHandle itself);

   156 static int FInfo_Convert(PyObject *v, FInfo *p_itself);

   157 #define FSRef_Convert PyMac_GetFSRef

   158 #define FSSpec_Convert PyMac_GetFSSpec

   159 static int Alias_Convert(PyObject *v, AliasHandle *p_itself);

   160 

   161 /*

   162 ** UTCDateTime records

   163 */

   164 static int

   165 UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr)

   166 {

   167         return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction);

   168 }

   169 

   170 static PyObject *

   171 UTCDateTime_New(UTCDateTime *ptr)

   172 {

   173         return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction);

   174 }

   175 

   176 /*

   177 ** Optional fsspec and fsref pointers. None will pass NULL

   178 */

   179 static int

   180 myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec)

   181 {

   182         if (v == Py_None) {

   183                 *spec = NULL;

   184                 return 1;

   185         }

   186         return PyMac_GetFSSpec(v, *spec);

   187 }

   188 

   189 static int

   190 myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref)

   191 {

   192         if (v == Py_None) {

   193                 *ref = NULL;

   194                 return 1;

   195         }

   196         return PyMac_GetFSRef(v, *ref);

   197 }

   198 

   199 /*

   200 ** Parse/generate objsect

   201 */

   202 static PyObject *

   203 PyMac_BuildHFSUniStr255(HFSUniStr255 *itself)

   204 {

   205 

   206         return Py_BuildValue("u#", itself->unicode, itself->length);

   207 }

   208 

   209 #ifndef __LP64__

   210 /*

   211 ** Get pathname for a given FSSpec

   212 */

   213 static OSErr

   214 _PyMac_GetFullPathname(FSSpec *fss, char *path, int len)

   215 {

   216         FSRef fsr;

   217         OSErr err;

   218 

   219         *path = '\0';

   220         err = FSpMakeFSRef(fss, &fsr);

   221         if (err == fnfErr) {

   222                 /* FSSpecs can point to non-existing files, fsrefs can't. */

   223                 FSSpec fss2;

   224                 int tocopy;

   225 

   226                 err = FSMakeFSSpec(fss->vRefNum, fss->parID, "", &fss2);

   227                 if (err)

   228                         return err;

   229                 err = FSpMakeFSRef(&fss2, &fsr);

   230                 if (err)

   231                         return err;

   232                 err = (OSErr)FSRefMakePath(&fsr, path, len-1);

   233                 if (err)

   234                         return err;

   235                 /* This part is not 100% safe: we append the filename part, but

   236                 ** I'm not sure that we don't run afoul of the various 8bit

   237                 ** encodings here. Will have to look this up at some point...

   238                 */

   239                 strcat(path, "/");

   240                 tocopy = fss->name[0];

   241                 if ((strlen(path) + tocopy) >= len)

   242                         tocopy = len - strlen(path) - 1;

   243                 if (tocopy > 0)

   244                         strncat(path, fss->name+1, tocopy);

   245         }

   246         else {

   247                 if (err)

   248                         return err;

   249                 err = (OSErr)FSRefMakePath(&fsr, path, len);

   250                 if (err)

   251                         return err;

   252         }

   253         return 0;

   254 }

   255 #endif /* !__LP64__ */

   256 

   257 """

   258 

   259 finalstuff = finalstuff + """

   260 

   261 #ifndef __LP64__

   262 int

   263 PyMac_GetFSSpec(PyObject *v, FSSpec *spec)

   264 {

   265         Str255 path;

   266         short refnum;

   267         long parid;

   268         OSErr err;

   269         FSRef fsr;

   270 

   271         if (FSSpec_Check(v)) {

   272                 *spec = ((FSSpecObject *)v)->ob_itself;

   273                 return 1;

   274         }

   275 

   276         if (PyArg_Parse(v, "(hlO&)",

   277                                                 &refnum, &parid, PyMac_GetStr255, &path)) {

   278                 err = FSMakeFSSpec(refnum, parid, path, spec);

   279                 if ( err && err != fnfErr ) {

   280                         PyMac_Error(err);

   281                         return 0;

   282                 }

   283                 return 1;

   284         }

   285         PyErr_Clear();

   286         /* Otherwise we try to go via an FSRef. On OSX we go all the way,

   287         ** on OS9 we accept only a real FSRef object

   288         */

   289         if ( PyMac_GetFSRef(v, &fsr) ) {

   290                 err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL);

   291                 if (err != noErr) {

   292                         PyMac_Error(err);

   293                         return 0;

   294                 }

   295                 return 1;

   296         }

   297         return 0;

   298 }

   299 

   300 #endif /* !__LP64__ */

   301 

   302 int

   303 PyMac_GetFSRef(PyObject *v, FSRef *fsr)

   304 {

   305         OSStatus err;

   306         FSSpec fss;

   307 

   308         if (FSRef_Check(v)) {

   309                 *fsr = ((FSRefObject *)v)->ob_itself;

   310                 return 1;

   311         }

   312 

   313         /* On OSX we now try a pathname */

   314         if ( PyString_Check(v) || PyUnicode_Check(v)) {

   315                 char *path = NULL;

   316                 if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path))

   317                         return 0;

   318                 if ( (err=FSPathMakeRef(path, fsr, NULL)) )

   319                         PyMac_Error(err);

   320                 PyMem_Free(path);

   321                 return !err;

   322         }

   323         /* XXXX Should try unicode here too */

   324         /* Otherwise we try to go via an FSSpec */

   325 #ifndef __LP64__

   326         if (FSSpec_Check(v)) {

   327                 fss = ((FSSpecObject *)v)->ob_itself;

   328                 if ((err=FSpMakeFSRef(&fss, fsr)) == 0)

   329                         return 1;

   330                 PyMac_Error(err);

   331                 return 0;

   332         }

   333         PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required");

   334 #else /* __LP64__ */

   335         PyErr_SetString(PyExc_TypeError, "FSRef or pathname required");

   336 #endif /* __LP64__ */

   337         return 0;

   338 }

   339 

   340 #ifndef __LP64__

   341 extern PyObject *

   342 PyMac_BuildFSSpec(FSSpec *spec)

   343 {

   344         return FSSpec_New(spec);

   345 }

   346 #endif /* __LP64__ */

   347 

   348 extern PyObject *

   349 PyMac_BuildFSRef(FSRef *spec)

   350 {

   351         return FSRef_New(spec);

   352 }

   353 """

   354 

   355 initstuff = initstuff + """

   356 #ifndef __LP64__

   357 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec);

   358 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec);

   359 #endif /* !__LP64__*/

   360 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef);

   361 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef);

   362 """

   363 

   364 execfile(string.lower(MODPREFIX) + 'typetest.py')

   365 

   366 # Our object types:

   367 class FSCatalogInfoDefinition(PEP253Mixin, ObjectDefinition):

   368     getsetlist = [

   369             ("nodeFlags",

   370              "return Py_BuildValue(\"H\", self->ob_itself.nodeFlags);",

   371              "return PyArg_Parse(v, \"H\", &self->ob_itself.nodeFlags)-1;",

   372              None

   373             ),

   374             ("volume",

   375              "return Py_BuildValue(\"h\", self->ob_itself.volume);",

   376              "return PyArg_Parse(v, \"h\", &self->ob_itself.volume)-1;",

   377              None

   378             ),

   379             ("parentDirID",

   380              "return Py_BuildValue(\"l\", self->ob_itself.parentDirID);",

   381              "return PyArg_Parse(v, \"l\", &self->ob_itself.parentDirID)-1;",

   382              None

   383             ),

   384             ("nodeID",

   385              "return Py_BuildValue(\"l\", self->ob_itself.nodeID);",

   386              "return PyArg_Parse(v, \"l\", &self->ob_itself.nodeID)-1;",

   387              None

   388             ),

   389             ("createDate",

   390              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.createDate);",

   391              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.createDate)-1;",

   392              None

   393             ),

   394             ("contentModDate",

   395              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.contentModDate);",

   396              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1;",

   397              None

   398             ),

   399             ("attributeModDate",

   400              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.attributeModDate);",

   401              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1;",

   402              None

   403             ),

   404             ("accessDate",

   405              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.accessDate);",

   406              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.accessDate)-1;",

   407              None

   408             ),

   409             ("backupDate",

   410              "return Py_BuildValue(\"O&\", UTCDateTime_New, &self->ob_itself.backupDate);",

   411              "return PyArg_Parse(v, \"O&\", UTCDateTime_Convert, &self->ob_itself.backupDate)-1;",

   412              None

   413             ),

   414             ("permissions",

   415              "return Py_BuildValue(\"(llll)\", self->ob_itself.permissions[0], self->ob_itself.permissions[1], self->ob_itself.permissions[2], self->ob_itself.permissions[3]);",

   416              "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;",

   417              None

   418             ),

   419             # XXXX FinderInfo TBD

   420             # XXXX FinderXInfo TBD

   421             ("valence",

   422              "return Py_BuildValue(\"l\", self->ob_itself.valence);",

   423              "return PyArg_Parse(v, \"l\", &self->ob_itself.valence)-1;",

   424              None

   425             ),

   426             ("dataLogicalSize",

   427              "return Py_BuildValue(\"l\", self->ob_itself.dataLogicalSize);",

   428              "return PyArg_Parse(v, \"l\", &self->ob_itself.dataLogicalSize)-1;",

   429              None

   430             ),

   431             ("dataPhysicalSize",

   432              "return Py_BuildValue(\"l\", self->ob_itself.dataPhysicalSize);",

   433              "return PyArg_Parse(v, \"l\", &self->ob_itself.dataPhysicalSize)-1;",

   434              None

   435             ),

   436             ("rsrcLogicalSize",

   437              "return Py_BuildValue(\"l\", self->ob_itself.rsrcLogicalSize);",

   438              "return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcLogicalSize)-1;",

   439              None

   440             ),

   441             ("rsrcPhysicalSize",

   442              "return Py_BuildValue(\"l\", self->ob_itself.rsrcPhysicalSize);",

   443              "return PyArg_Parse(v, \"l\", &self->ob_itself.rsrcPhysicalSize)-1;",

   444              None

   445             ),

   446             ("sharingFlags",

   447              "return Py_BuildValue(\"l\", self->ob_itself.sharingFlags);",

   448              "return PyArg_Parse(v, \"l\", &self->ob_itself.sharingFlags)-1;",

   449              None

   450             ),

   451             ("userPrivileges",

   452              "return Py_BuildValue(\"b\", self->ob_itself.userPrivileges);",

   453              "return PyArg_Parse(v, \"b\", &self->ob_itself.userPrivileges)-1;",

   454              None

   455             ),

   456     ]

   457     # The same info, but in a different form

   458     INITFORMAT = "HhllO&O&O&O&O&llllllb"

   459     INITARGS = """&((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags,

   460             &((FSCatalogInfoObject *)_self)->ob_itself.volume,

   461             &((FSCatalogInfoObject *)_self)->ob_itself.parentDirID,

   462             &((FSCatalogInfoObject *)_self)->ob_itself.nodeID,

   463             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate,

   464             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate,

   465             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate,

   466             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate,

   467             UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate,

   468             &((FSCatalogInfoObject *)_self)->ob_itself.valence,

   469             &((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize,

   470             &((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize,

   471             &((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize,

   472             &((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize,

   473             &((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags,

   474             &((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges"""

   475     INITNAMES = """

   476             "nodeFlags",

   477             "volume",

   478             "parentDirID",

   479             "nodeID",

   480             "createDate",

   481             "contentModDate",

   482             "atributeModDate",

   483             "accessDate",

   484             "backupDate",

   485             "valence",

   486             "dataLogicalSize",

   487             "dataPhysicalSize",

   488             "rsrcLogicalSize",

   489             "rsrcPhysicalSize",

   490             "sharingFlags",

   491             "userPrivileges"

   492             """

   493 

   494     def __init__(self, name, prefix, itselftype):

   495         ObjectDefinition.__init__(self, name, prefix, itselftype)

   496         self.argref = "*"       # Store FSSpecs, but pass them by address

   497 

   498     def outputCheckNewArg(self):

   499         Output("if (itself == NULL) { Py_INCREF(Py_None); return Py_None; }")

   500 

   501     def output_tp_newBody(self):

   502         Output("PyObject *self;");

   503         Output()

   504         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")

   505         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",

   506                 self.objecttype, self.itselftype)

   507         Output("return self;")

   508 

   509     def output_tp_initBody(self):

   510         Output("static char *kw[] = {%s, 0};", self.INITNAMES)

   511         Output()

   512         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|%s\", kw, %s))",

   513                 self.INITFORMAT, self.INITARGS)

   514         OutLbrace()

   515         Output("return -1;")

   516         OutRbrace()

   517         Output("return 0;")

   518 

   519 class FInfoDefinition(PEP253Mixin, ObjectDefinition):

   520     getsetlist = [

   521             ("Type",

   522              "return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdType);",

   523              "return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdType)-1;",

   524              "4-char file type"

   525             ),

   526             ("Creator",

   527              "return Py_BuildValue(\"O&\", PyMac_BuildOSType, self->ob_itself.fdCreator);",

   528              "return PyArg_Parse(v, \"O&\", PyMac_GetOSType, &self->ob_itself.fdCreator)-1;",

   529              "4-char file creator"

   530             ),

   531             ("Flags",

   532              "return Py_BuildValue(\"H\", self->ob_itself.fdFlags);",

   533              "return PyArg_Parse(v, \"H\", &self->ob_itself.fdFlags)-1;",

   534              "Finder flag bits"

   535             ),

   536             ("Location",

   537              "return Py_BuildValue(\"O&\", PyMac_BuildPoint, self->ob_itself.fdLocation);",

   538              "return PyArg_Parse(v, \"O&\", PyMac_GetPoint, &self->ob_itself.fdLocation)-1;",

   539              "(x, y) location of the file's icon in its parent finder window"

   540             ),

   541             ("Fldr",

   542              "return Py_BuildValue(\"h\", self->ob_itself.fdFldr);",

   543              "return PyArg_Parse(v, \"h\", &self->ob_itself.fdFldr)-1;",

   544              "Original folder, for 'put away'"

   545             ),

   546 

   547     ]

   548 

   549     def __init__(self, name, prefix, itselftype):

   550         ObjectDefinition.__init__(self, name, prefix, itselftype)

   551         self.argref = "*"       # Store FSSpecs, but pass them by address

   552 

   553     def outputCheckNewArg(self):

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

   555 

   556     def output_tp_newBody(self):

   557         Output("PyObject *self;");

   558         Output()

   559         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")

   560         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",

   561                 self.objecttype, self.itselftype)

   562         Output("return self;")

   563 

   564     def output_tp_initBody(self):

   565         Output("%s *itself = NULL;", self.itselftype)

   566         Output("static char *kw[] = {\"itself\", 0};")

   567         Output()

   568         Output("if (PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&\", kw, FInfo_Convert, &itself))")

   569         OutLbrace()

   570         Output("if (itself) memcpy(&((%s *)_self)->ob_itself, itself, sizeof(%s));",

   571                 self.objecttype, self.itselftype)

   572         Output("return 0;")

   573         OutRbrace()

   574         Output("return -1;")

   575 

   576 class FSSpecDefinition(PEP253Mixin, ObjectDefinition):

   577     getsetlist = [

   578             ("data",

   579              "return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",

   580              None,

   581              "Raw data of the FSSpec object"

   582             )

   583     ]

   584 

   585     def __init__(self, name, prefix, itselftype):

   586         ObjectDefinition.__init__(self, name, prefix, itselftype)

   587         self.argref = "*"       # Store FSSpecs, but pass them by address

   588 

   589     def outputCheckNewArg(self):

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

   591 

   592     # We do Convert ourselves (with PyMac_GetFSxxx)

   593     def outputConvert(self):

   594         pass

   595 

   596     def output_tp_newBody(self):

   597         Output("PyObject *self;");

   598         Output()

   599         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")

   600         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",

   601                 self.objecttype, self.itselftype)

   602         Output("return self;")

   603 

   604     def output_tp_initBody(self):

   605         Output("PyObject *v = NULL;")

   606         Output("char *rawdata = NULL;")

   607         Output("int rawdatalen = 0;")

   608         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")

   609         Output()

   610         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")

   611         Output("return -1;")

   612         Output("if (v && rawdata)")

   613         OutLbrace()

   614         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")

   615         Output("return -1;")

   616         OutRbrace()

   617         Output("if (!v && !rawdata)")

   618         OutLbrace()

   619         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")

   620         Output("return -1;")

   621         OutRbrace()

   622         Output("if (rawdata)")

   623         OutLbrace()

   624         Output("if (rawdatalen != sizeof(%s))", self.itselftype)

   625         OutLbrace()

   626         Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",

   627                 self.itselftype)

   628         Output("return -1;")

   629         OutRbrace()

   630         Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)

   631         Output("return 0;")

   632         OutRbrace()

   633         Output("if (PyMac_GetFSSpec(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)

   634         Output("return -1;")

   635 

   636     def outputRepr(self):

   637         Output()

   638         Output("static PyObject * %s_repr(%s *self)", self.prefix, self.objecttype)

   639         OutLbrace()

   640         Output("char buf[512];")

   641         Output("""PyOS_snprintf(buf, sizeof(buf), \"%%s((%%d, %%ld, '%%.*s'))\",

   642         self->ob_type->tp_name,

   643         self->ob_itself.vRefNum,

   644         self->ob_itself.parID,

   645         self->ob_itself.name[0], self->ob_itself.name+1);""")

   646         Output("return PyString_FromString(buf);")

   647         OutRbrace()

   648 

   649 class FSRefDefinition(PEP253Mixin, ObjectDefinition):

   650     getsetlist = [

   651             ("data",

   652              "return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself));",

   653              None,

   654              "Raw data of the FSRef object"

   655             )

   656     ]

   657 

   658     def __init__(self, name, prefix, itselftype):

   659         ObjectDefinition.__init__(self, name, prefix, itselftype)

   660         self.argref = "*"       # Store FSRefs, but pass them by address

   661 

   662     def outputCheckNewArg(self):

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

   664 

   665     # We do Convert ourselves (with PyMac_GetFSxxx)

   666     def outputConvert(self):

   667         pass

   668 

   669     def output_tp_newBody(self):

   670         Output("PyObject *self;");

   671         Output()

   672         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")

   673         Output("memset(&((%s *)self)->ob_itself, 0, sizeof(%s));",

   674                 self.objecttype, self.itselftype)

   675         Output("return self;")

   676 

   677     def output_tp_initBody(self):

   678         Output("PyObject *v = NULL;")

   679         Output("char *rawdata = NULL;")

   680         Output("int rawdatalen = 0;")

   681         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")

   682         Output()

   683         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|Os#\", kw, &v, &rawdata, &rawdatalen))")

   684         Output("return -1;")

   685         Output("if (v && rawdata)")

   686         OutLbrace()

   687         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")

   688         Output("return -1;")

   689         OutRbrace()

   690         Output("if (!v && !rawdata)")

   691         OutLbrace()

   692         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")

   693         Output("return -1;")

   694         OutRbrace()

   695         Output("if (rawdata)")

   696         OutLbrace()

   697         Output("if (rawdatalen != sizeof(%s))", self.itselftype)

   698         OutLbrace()

   699         Output("PyErr_SetString(PyExc_TypeError, \"%s rawdata incorrect size\");",

   700                 self.itselftype)

   701         Output("return -1;")

   702         OutRbrace()

   703         Output("memcpy(&((%s *)_self)->ob_itself, rawdata, rawdatalen);", self.objecttype)

   704         Output("return 0;")

   705         OutRbrace()

   706         Output("if (PyMac_GetFSRef(v, &((%s *)_self)->ob_itself)) return 0;", self.objecttype)

   707         Output("return -1;")

   708 

   709 class AliasDefinition(PEP253Mixin, ObjectDefinition):

   710     # XXXX Should inherit from resource?

   711     getsetlist = [

   712             ("data",

   713              """int size;

   714                     PyObject *rv;

   715 

   716                     size = GetHandleSize((Handle)self->ob_itself);

   717                     HLock((Handle)self->ob_itself);

   718                     rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size);

   719                     HUnlock((Handle)self->ob_itself);

   720                     return rv;

   721             """,

   722              None,

   723              "Raw data of the alias object"

   724             )

   725     ]

   726 

   727     def outputCheckNewArg(self):

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

   729 

   730     def outputStructMembers(self):

   731         ObjectDefinition.outputStructMembers(self)

   732         Output("void (*ob_freeit)(%s ptr);", self.itselftype)

   733 

   734     def outputInitStructMembers(self):

   735         ObjectDefinition.outputInitStructMembers(self)

   736         Output("it->ob_freeit = NULL;")

   737 

   738     def outputCleanupStructMembers(self):

   739         Output("if (self->ob_freeit && self->ob_itself)")

   740         OutLbrace()

   741         Output("self->ob_freeit(self->ob_itself);")

   742         OutRbrace()

   743         Output("self->ob_itself = NULL;")

   744 

   745     def output_tp_newBody(self):

   746         Output("PyObject *self;");

   747         Output()

   748         Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")

   749         Output("((%s *)self)->ob_itself = NULL;", self.objecttype)

   750         Output("return self;")

   751 

   752     def output_tp_initBody(self):

   753         Output("%s itself = NULL;", self.itselftype)

   754         Output("char *rawdata = NULL;")

   755         Output("int rawdatalen = 0;")

   756         Output("Handle h;")

   757         Output("static char *kw[] = {\"itself\", \"rawdata\", 0};")

   758         Output()

   759         Output("if (!PyArg_ParseTupleAndKeywords(_args, _kwds, \"|O&s#\", kw, %s_Convert, &itself, &rawdata, &rawdatalen))",

   760                 self.prefix)

   761         Output("return -1;")

   762         Output("if (itself && rawdata)")

   763         OutLbrace()

   764         Output("PyErr_SetString(PyExc_TypeError, \"Only one of itself or rawdata may be specified\");")

   765         Output("return -1;")

   766         OutRbrace()

   767         Output("if (!itself && !rawdata)")

   768         OutLbrace()

   769         Output("PyErr_SetString(PyExc_TypeError, \"One of itself or rawdata must be specified\");")

   770         Output("return -1;")

   771         OutRbrace()

   772         Output("if (rawdata)")

   773         OutLbrace()

   774         Output("if ((h = NewHandle(rawdatalen)) == NULL)")

   775         OutLbrace()

   776         Output("PyErr_NoMemory();")

   777         Output("return -1;")

   778         OutRbrace()

   779         Output("HLock(h);")

   780         Output("memcpy((char *)*h, rawdata, rawdatalen);")

   781         Output("HUnlock(h);")

   782         Output("((%s *)_self)->ob_itself = (%s)h;", self.objecttype, self.itselftype)

   783         Output("return 0;")

   784         OutRbrace()

   785         Output("((%s *)_self)->ob_itself = itself;", self.objecttype)

   786         Output("return 0;")

   787 

   788 # Alias methods come in two flavors: those with the alias as arg1 and

   789 # those with the alias as arg 2.

   790 class Arg2MethodGenerator(OSErrMethodGenerator):

   791     """Similar to MethodGenerator, but has self as second argument"""

   792 

   793     def parseArgumentList(self, args):

   794         args0, arg1, argsrest = args[:1], args[1], args[2:]

   795         t0, n0, m0 = arg1

   796         args = args0 + argsrest

   797         if m0 != InMode:

   798             raise ValueError, "method's 'self' must be 'InMode'"

   799         self.itself = Variable(t0, "_self->ob_itself", SelfMode)

   800         FunctionGenerator.parseArgumentList(self, args)

   801         self.argumentList.insert(2, self.itself)

   802 

   803 # From here on it's basically all boiler plate...

   804 

   805 # Create the generator groups and link them

   806 module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff,

   807         longname=LONGMODNAME)

   808 

   809 fscataloginfoobject = FSCatalogInfoDefinition('FSCatalogInfo', 'FSCatalogInfo', 'FSCatalogInfo')

   810 finfoobject = FInfoDefinition('FInfo', 'FInfo', 'FInfo')

   811 aliasobject = AliasDefinition('Alias', 'Alias', 'AliasHandle')

   812 fsspecobject = FSSpecDefinition('FSSpec', 'FSSpec', 'FSSpec')

   813 fsrefobject = FSRefDefinition('FSRef', 'FSRef', 'FSRef')

   814 

   815 module.addobject(fscataloginfoobject)

   816 module.addobject(finfoobject)

   817 module.addobject(aliasobject)

   818 module.addobject(fsspecobject)

   819 module.addobject(fsrefobject)

   820 

   821 # Create the generator classes used to populate the lists

   822 Function = OSErrFunctionGenerator

   823 Method = OSErrMethodGenerator

   824 

   825 # Create and populate the lists

   826 functions = []

   827 alias_methods = []

   828 fsref_methods = []

   829 fsspec_methods = []

   830 execfile(INPUTFILE)

   831 

   832 # Manual generators:

   833 FSRefMakePath_body = """

   834 OSStatus _err;

   835 #define MAXPATHNAME 1024

   836 UInt8 path[MAXPATHNAME];

   837 UInt32 maxPathSize = MAXPATHNAME;

   838 

   839 if (!PyArg_ParseTuple(_args, ""))

   840         return NULL;

   841 _err = FSRefMakePath(&_self->ob_itself,

   842                                          path,

   843                                          maxPathSize);

   844 if (_err != noErr) return PyMac_Error(_err);

   845 _res = Py_BuildValue("s", path);

   846 return _res;

   847 """

   848 f = ManualGenerator("FSRefMakePath", FSRefMakePath_body)

   849 f.docstring = lambda: "() -> string"

   850 fsref_methods.append(f)

   851 

   852 FSRef_as_pathname_body = """

   853 if (!PyArg_ParseTuple(_args, ""))

   854         return NULL;

   855 _res = FSRef_FSRefMakePath(_self, _args);

   856 return _res;

   857 """

   858 f = ManualGenerator("as_pathname", FSRef_as_pathname_body)

   859 f.docstring = lambda: "() -> string"

   860 fsref_methods.append(f)

   861 

   862 FSSpec_as_pathname_body = """

   863 char strbuf[1024];

   864 OSErr err;

   865 

   866 if (!PyArg_ParseTuple(_args, ""))

   867         return NULL;

   868 err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf));

   869 if ( err ) {

   870         PyMac_Error(err);

   871         return NULL;

   872 }

   873 _res = PyString_FromString(strbuf);

   874 return _res;

   875 """

   876 f = ManualGenerator("as_pathname", FSSpec_as_pathname_body)

   877 f.docstring = lambda: "() -> string"

   878 fsspec_methods.append(f)

   879 

   880 FSSpec_as_tuple_body = """

   881 if (!PyArg_ParseTuple(_args, ""))

   882         return NULL;

   883 _res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID,

   884                                         &_self->ob_itself.name[1], _self->ob_itself.name[0]);

   885 return _res;

   886 """

   887 f = ManualGenerator("as_tuple", FSSpec_as_tuple_body)

   888 f.docstring = lambda: "() -> (vRefNum, dirID, name)"

   889 fsspec_methods.append(f)

   890 

   891 pathname_body = """

   892 PyObject *obj;

   893 

   894 if (!PyArg_ParseTuple(_args, "O", &obj))

   895         return NULL;

   896 if (PyString_Check(obj)) {

   897         Py_INCREF(obj);

   898         return obj;

   899 }

   900 if (PyUnicode_Check(obj))

   901         return PyUnicode_AsEncodedString(obj, "utf8", "strict");

   902 _res = PyObject_CallMethod(obj, "as_pathname", NULL);

   903 return _res;

   904 """

   905 f = ManualGenerator("pathname", pathname_body)

   906 f.docstring = lambda: "(str|unicode|FSSpec|FSref) -> pathname"

   907 functions.append(f)

   908 

   909 # add the populated lists to the generator groups

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

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

   912 for f in alias_methods: aliasobject.add(f)

   913 for f in fsspec_methods: fsspecobject.add(f)

   914 for f in fsref_methods: fsrefobject.add(f)

   915 

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

   917 SetOutputFileName(OUTPUTFILE)

   918 module.generate()