Ticket #22278: patch-macosmodule.diff

File patch-macosmodule.diff, 10.0 KB (added by jaroel (Roel Bruggink), 14 years ago)

  • Mac/Modules/macosmodule.c

     
    4040
    4141typedef struct {
    4242        PyObject_HEAD
    43         short fRefNum;
     43        FSIORefNum fRefNum;
    4444        int isclosed;
    4545} rfobject;
    4646
    … …  
    5454do_close(rfobject *self)
    5555{
    5656        if (self->isclosed ) return;
    57         (void)FSClose(self->fRefNum);
     57        (void)FSCloseFork(self->fRefNum);
    5858        self->isclosed = 1;
    5959}
    6060
    … …  
    6868        long n;
    6969        PyObject *v;
    7070        OSErr err;
     71        ByteCount n2;
    7172       
    7273        if (self->isclosed) {
    7374                PyErr_SetString(PyExc_ValueError, "Operation on closed file");
    … …  
    8182        if (v == NULL)
    8283                return NULL;
    8384               
    84         err = FSRead(self->fRefNum, &n, PyString_AsString(v));
     85        err = FSReadFork(self->fRefNum, fsAtMark, 0, n, PyString_AsString(v), &n2);
    8586        if (err && err != eofErr) {
    8687                PyMac_Error(err);
    8788                Py_DECREF(v);
    8889                return NULL;
    8990        }
    90         _PyString_Resize(&v, n);
     91        _PyString_Resize(&v, n2);
    9192        return v;
    9293}
    9394
    … …  
    109110        }
    110111        if (!PyArg_ParseTuple(args, "s#", &buffer, &size))
    111112                return NULL;
    112         err = FSWrite(self->fRefNum, &size, buffer);
     113        err = FSWriteFork(self->fRefNum, fsAtMark, 0, size, buffer, NULL);
    113114        if (err) {
    114115                PyMac_Error(err);
    115116                return NULL;
    … …  
    126127static PyObject *
    127128rf_seek(rfobject *self, PyObject *args)
    128129{
    129         long amount, pos;
     130        long amount;
    130131        int whence = SEEK_SET;
    131         long eof;
     132        int mode;
    132133        OSErr err;
    133134       
    134135        if (self->isclosed) {
    135136                PyErr_SetString(PyExc_ValueError, "Operation on closed file");
    136137                return NULL;
    137138        }
    138         if (!PyArg_ParseTuple(args, "l|i", &amount, &whence))
     139        if (!PyArg_ParseTuple(args, "l|i", &amount, &whence)) {
    139140                return NULL;
    140        
    141         if ((err = GetEOF(self->fRefNum, &eof)))
    142                 goto ioerr;
     141        }
    143142       
    144143        switch (whence) {
    145144        case SEEK_CUR:
    146                 if ((err = GetFPos(self->fRefNum, &pos)))
    147                         goto ioerr;
     145                mode = fsFromMark;
    148146                break;
    149147        case SEEK_END:
    150                 pos = eof;
     148                mode = fsFromLEOF;
    151149                break;
    152150        case SEEK_SET:
    153                 pos = 0;
     151                mode = fsFromStart;
    154152                break;
    155153        default:
    156154                PyErr_BadArgument();
    157155                return NULL;
    158156        }
    159        
    160         pos += amount;
    161        
    162         /* Don't bother implementing seek past EOF */
    163         if (pos > eof || pos < 0) {
    164                 PyErr_BadArgument();
    165                 return NULL;
    166         }
    167        
    168         if ((err = SetFPos(self->fRefNum, fsFromStart, pos)) ) {
    169 ioerr:
     157
     158        err = FSSetForkPosition(self->fRefNum, mode, amount);
     159        if (err != noErr) {
    170160                PyMac_Error(err);
    171161                return NULL;
    172162        }
    … …  
    182172static PyObject *
    183173rf_tell(rfobject *self, PyObject *args)
    184174{
    185         long where;
     175        long long where;
    186176        OSErr err;
    187177       
    188178        if (self->isclosed) {
    … …  
    191181        }
    192182        if (!PyArg_ParseTuple(args, ""))
    193183                return NULL;
    194         if ((err = GetFPos(self->fRefNum, &where)) ) {
     184
     185        err = FSGetForkPosition(self->fRefNum, &where);
     186        if (err != noErr) {
    195187                PyMac_Error(err);
    196188                return NULL;
    197189        }
    198         return PyInt_FromLong(where);
     190        return PyLong_FromLongLong(where);
    199191}
    200192
    201193static char rf_close__doc__[] =
    … …  
    281273        Rftype__doc__ /* Documentation string */
    282274};
    283275
     276
    284277/* End of code for Resource fork objects */
    285278/* -------------------------------------------------------- */
    286279
    … …  
    292285static PyObject *
    293286MacOS_GetCreatorAndType(PyObject *self, PyObject *args)
    294287{
    295         FSSpec fss;
    296         FInfo info;
    297288        PyObject *creator, *type, *res;
    298289        OSErr err;
    299        
    300         if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSSpec, &fss))
     290        FSRef ref;
     291        FSCatalogInfo   cataloginfo;
     292        FileInfo* finfo;
     293
     294        if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSRef, &ref)) {
     295#ifndef __LP64__
     296                /* This function is documented to take an FSSpec as well,
     297                 * which only works in 32-bit mode.
     298                 */
     299                PyErr_Clear();
     300                FSSpec fss;
     301                FInfo info;
     302
     303                if (!PyArg_ParseTuple(args, "O&", PyMac_GetFSSpec, &fss))
     304                        return NULL;
     305
     306                if ((err = FSpGetFInfo(&fss, &info)) != noErr) {
     307                        return PyErr_Mac(MacOS_Error, err);
     308                }
     309                creator = PyString_FromStringAndSize(
     310                                (char *)&info.fdCreator, 4);
     311                type = PyString_FromStringAndSize((char *)&info.fdType, 4);
     312                res = Py_BuildValue("OO", creator, type);
     313                Py_DECREF(creator);
     314                Py_DECREF(type);
     315                return res;
     316#else   /* __LP64__ */
     317                return NULL;
     318#endif  /* __LP64__ */
     319        }
     320
     321        err = FSGetCatalogInfo(&ref,
     322                        kFSCatInfoFinderInfo|kFSCatInfoNodeFlags, &cataloginfo,
     323                        NULL, NULL, NULL);
     324        if (err != noErr) {
     325                PyErr_Mac(MacOS_Error, err);
    301326                return NULL;
    302         if ((err = FSpGetFInfo(&fss, &info)) != noErr)
    303                 return PyErr_Mac(MacOS_Error, err);
    304         creator = PyString_FromStringAndSize((char *)&info.fdCreator, 4);
    305         type = PyString_FromStringAndSize((char *)&info.fdType, 4);
     327        }
     328
     329        if ((cataloginfo.nodeFlags & kFSNodeIsDirectoryMask) != 0) {
     330                /* Directory: doesn't have type/creator info.
     331                 *
     332                 * The specific error code is for backward compatibility with
     333                 * earlier versions.
     334                 */
     335                PyErr_Mac(MacOS_Error, fnfErr);
     336                return NULL;
     337
     338        }
     339        finfo = (FileInfo*)&(cataloginfo.finderInfo);
     340        creator = PyString_FromStringAndSize((char*)&(finfo->fileCreator), 4);
     341        type = PyString_FromStringAndSize((char*)&(finfo->fileType), 4);
     342
    306343        res = Py_BuildValue("OO", creator, type);
    307344        Py_DECREF(creator);
    308345        Py_DECREF(type);
    … …  
    314351static PyObject *
    315352MacOS_SetCreatorAndType(PyObject *self, PyObject *args)
    316353{
    317         FSSpec fss;
    318354        ResType creator, type;
    319         FInfo info;
     355        FSRef ref;
     356        FileInfo* finfo;
    320357        OSErr err;
    321        
     358        FSCatalogInfo   cataloginfo;
     359
    322360        if (!PyArg_ParseTuple(args, "O&O&O&",
     361                        PyMac_GetFSRef, &ref, PyMac_GetOSType, &creator, PyMac_GetOSType, &type)) {
     362#ifndef __LP64__
     363                /* Try to handle FSSpec arguments, for backward compatibility */
     364                FSSpec fss;
     365                FInfo info;
     366
     367                if (!PyArg_ParseTuple(args, "O&O&O&",
    323368                        PyMac_GetFSSpec, &fss, PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
     369                        return NULL;
     370
     371                if ((err = FSpGetFInfo(&fss, &info)) != noErr)
     372                        return PyErr_Mac(MacOS_Error, err);
     373
     374                info.fdCreator = creator;
     375                info.fdType = type;
     376
     377                if ((err = FSpSetFInfo(&fss, &info)) != noErr)
     378                        return PyErr_Mac(MacOS_Error, err);
     379                Py_INCREF(Py_None);
     380                return Py_None;
     381#else /* __LP64__ */
    324382                return NULL;
    325         if ((err = FSpGetFInfo(&fss, &info)) != noErr)
    326                 return PyErr_Mac(MacOS_Error, err);
    327         info.fdCreator = creator;
    328         info.fdType = type;
    329         if ((err = FSpSetFInfo(&fss, &info)) != noErr)
    330                 return PyErr_Mac(MacOS_Error, err);
     383#endif /* __LP64__ */
     384        }
     385       
     386        err = FSGetCatalogInfo(&ref,
     387                        kFSCatInfoFinderInfo|kFSCatInfoNodeFlags, &cataloginfo,
     388                        NULL, NULL, NULL);
     389        if (err != noErr) {
     390                PyErr_Mac(MacOS_Error, err);
     391                return NULL;
     392        }
     393
     394        if ((cataloginfo.nodeFlags & kFSNodeIsDirectoryMask) != 0) {
     395                /* Directory: doesn't have type/creator info.
     396                 *
     397                 * The specific error code is for backward compatibility with
     398                 * earlier versions.
     399                 */
     400                PyErr_Mac(MacOS_Error, fnfErr);
     401                return NULL;
     402
     403        }
     404        finfo = (FileInfo*)&(cataloginfo.finderInfo);
     405        finfo->fileCreator = creator;
     406        finfo->fileType = type;
     407
     408        err = FSSetCatalogInfo(&ref, kFSCatInfoFinderInfo, &cataloginfo);
     409        if (err != noErr) {
     410                PyErr_Mac(MacOS_Error, fnfErr);
     411                return NULL;
     412        }
     413
    331414        Py_INCREF(Py_None);
    332415        return Py_None;
    333416}
    … …  
    375458                                /* And try again... */
    376459                                h = GetResource('Estr', err);
    377460                        }
     461                        Py_DECREF(m);
    378462                }
    379463        }
    380464        /*
    … …  
    398482        return Py_BuildValue("s", buf);
    399483}
    400484
     485
     486#ifndef __LP64__
     487
    401488static char splash_doc[] = "Open a splash-screen dialog by resource-id (0=close)";
    402489
    403490static PyObject *
    … …  
    416503                return NULL;
    417504        olddialog = curdialog;
    418505        curdialog = NULL;
    419                
     506
    420507        if ( resid != -1 ) {
    421508                curdialog = GetNewDialog(resid, NULL, (WindowPtr)-1);
    422509                if ( curdialog ) {
    … …  
    451538       
    452539        if (!PyArg_ParseTuple(args, "O&|O", PyMac_GetStr255, message, &object))
    453540                return NULL;
     541       
    454542        DebugStr(message);
    455543        Py_INCREF(Py_None);
    456544        return Py_None;
    457545}
    458546
     547
    459548static char SysBeep_doc[] = "BEEEEEP!!!";
    460549
    461550static PyObject *
    … …  
    470559        return Py_None;
    471560}
    472561
     562#endif /* __LP64__ */
     563
    473564static char WMAvailable_doc[] =
    474565        "True if this process can interact with the display."
    475566        "Will foreground the application on the first call as a side-effect."
    … …  
    529620{
    530621        OSErr err;
    531622        char *mode = "r";
    532         FSSpec fss;
    533         SignedByte permission = 1;
     623        FSRef ref;
     624        SInt8 permission = fsRdPerm;
    534625        rfobject *fp;
     626        HFSUniStr255 name;
    535627               
    536         if (!PyArg_ParseTuple(args, "O&|s", PyMac_GetFSSpec, &fss, &mode))
     628        if (!PyArg_ParseTuple(args, "O&|s", PyMac_GetFSRef, &ref, &mode))
    537629                return NULL;
    538630        while (*mode) {
    539631                switch (*mode++) {
    540632                case '*': break;
    541                 case 'r': permission = 1; break;
    542                 case 'w': permission = 2; break;
     633                case 'r': permission = fsRdPerm; break;
     634                case 'w': permission = fsWrPerm; break;
    543635                case 'b': break;
    544636                default:
    545637                        PyErr_BadArgument();
    546638                        return NULL;
    547639                }
    548640        }
     641
     642        err = FSGetResourceForkName(&name);
     643        if (err != noErr) {
     644                PyMac_Error(err);
     645                return NULL;
     646        }
    549647       
    550648        if ( (fp = newrfobject()) == NULL )
    551649                return NULL;
    552                
    553         err = HOpenRF(fss.vRefNum, fss.parID, fss.name, permission, &fp->fRefNum);
     650
    554651       
    555         if ( err == fnfErr ) {
    556                 /* In stead of doing complicated things here to get creator/type
    557                 ** correct we let the standard i/o library handle it
    558                 */
    559                 FILE *tfp;
    560                 char pathname[PATHNAMELEN];
    561                
    562                 if ( (err=PyMac_GetFullPathname(&fss, pathname, PATHNAMELEN)) ) {
    563                         PyMac_Error(err);
    564                         Py_DECREF(fp);
    565                         return NULL;
    566                 }
    567                
    568                 if ( (tfp = fopen(pathname, "w")) == NULL ) {
    569                         PyMac_Error(fnfErr); /* What else... */
    570                         Py_DECREF(fp);
    571                         return NULL;
    572                 }
    573                 fclose(tfp);
    574                 err = HOpenRF(fss.vRefNum, fss.parID, fss.name, permission, &fp->fRefNum);
    575         }
    576         if ( err ) {
     652        err = FSOpenFork(&ref, name.length, name.unicode, permission, &fp->fRefNum);
     653        if (err != noErr) {
    577654                Py_DECREF(fp);
    578655                PyMac_Error(err);
    579656                return NULL;
    … …  
    583660}
    584661
    585662
     663
    586664static PyMethodDef MacOS_Methods[] = {
    587665        {"GetCreatorAndType",           MacOS_GetCreatorAndType, 1,     getcrtp_doc},
    588666        {"SetCreatorAndType",           MacOS_SetCreatorAndType, 1,     setcrtp_doc},
    589667        {"GetErrorString",              MacOS_GetErrorString,   1,      geterr_doc},
    590668        {"openrf",                      MacOS_openrf,           1,      openrf_doc},
     669#ifndef __LP64__
    591670        {"splash",                      MacOS_splash,           1,      splash_doc},
    592671        {"DebugStr",                    MacOS_DebugStr,         1,      DebugStr_doc},
    593         {"GetTicks",                    MacOS_GetTicks,         1,      GetTicks_doc},
    594672        {"SysBeep",                     MacOS_SysBeep,          1,      SysBeep_doc},
     673#endif /* __LP64__ */
     674        {"GetTicks",                    MacOS_GetTicks,         1,      GetTicks_doc},
    595675        {"WMAvailable",                 MacOS_WMAvailable,              1,      WMAvailable_doc},
    596676        {NULL,                          NULL}            /* Sentinel */
    597677};