Mac/Modules/macfsmodule.c

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI not be used in advertising or publicity pertaining to
  13 distribution of the software without specific, written prior permission.
  14
  15 STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16 THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17 FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 #include "allobjects.h"
  26 #include "modsupport.h"         /* For getargs() etc. */
  27 #include "macglue.h"
  28
  29 #include <Memory.h>
  30 #include <Files.h>
  31 #include <Folders.h>
  32 #include <StandardFile.h>
  33 #include <Aliases.h>
  34 #include <LowMem.h>
  35
  36 #include "nfullpath.h"
  37
  38 #ifdef THINK_C
  39 #define FileFilterUPP FileFilterProcPtr
  40 #endif
  41
  42 static object *ErrorObject;
  43
  44 /* ----------------------------------------------------- */
  45 /* Declarations for objects of type Alias */
  46
  47 typedef struct {
  48         OB_HEAD
  49         AliasHandle alias;
  50 } mfsaobject;
  51
  52 staticforward typeobject Mfsatype;
  53
  54 #define is_mfsaobject(v)                ((v)->ob_type == &Mfsatype)
  55
  56 /* ---------------------------------------------------------------- */
  57 /* Declarations for objects of type FSSpec */
  58
  59 typedef struct {
  60         OB_HEAD
  61         FSSpec fsspec;
  62 } mfssobject;
  63
  64 staticforward typeobject Mfsstype;
  65
  66 #define is_mfssobject(v)                ((v)->ob_type == &Mfsstype)
  67
  68
  69 /* ---------------------------------------------------------------- */
  70 /* Declarations for objects of type FInfo */
  71
  72 typedef struct {
  73         OB_HEAD
  74         FInfo finfo;
  75 } mfsiobject;
  76
  77 staticforward typeobject Mfsitype;
  78
  79 #define is_mfsiobject(v)                ((v)->ob_type == &Mfsitype)
  80
  81
  82 mfssobject *newmfssobject(FSSpec *fss); /* Forward */
  83
  84 /* ---------------------------------------------------------------- */
  85
  86 static object *
  87 mfsa_Resolve(self, args)
  88         mfsaobject *self;
  89         object *args;
  90 {
  91         FSSpec from, *fromp, result;
  92         Boolean changed;
  93         OSErr err;
  94
  95         from.name[0] = 0;
  96         if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &from))
  97                 return NULL;
  98         if (from.name[0] )
  99                 fromp = &from;
 100         else
 101                 fromp = NULL;
 102         err = ResolveAlias(fromp, self->alias, &result, &changed);
 103         if ( err ) {
 104                 PyErr_Mac(ErrorObject, err);
 105                 return NULL;
 106         }
 107         return mkvalue("(Oi)", newmfssobject(&result), (int)changed);
 108 }
 109
 110 static object *
 111 mfsa_GetInfo(self, args)
 112         mfsaobject *self;
 113         object *args;
 114 {
 115         Str63 value;
 116         int i;
 117         OSErr err;
 118
 119         if (!newgetargs(args, "i", &i))
 120                 return NULL;
 121         err = GetAliasInfo(self->alias, (AliasInfoType)i, value);
 122         if ( err ) {
 123                 PyErr_Mac(ErrorObject, err);
 124                 return 0;
 125         }
 126         return newsizedstringobject((char *)&value[1], value[0]);
 127 }
 128
 129 static object *
 130 mfsa_Update(self, args)
 131         mfsaobject *self;
 132         object *args;
 133 {
 134         FSSpec target, fromfile, *fromfilep;
 135         OSErr err;
 136         Boolean changed;
 137
 138         fromfile.name[0] = 0;
 139         if (!newgetargs(args, "O&|O&",  PyMac_GetFSSpec, &target,
 140                                          PyMac_GetFSSpec, &fromfile))
 141                 return NULL;
 142         if ( fromfile.name[0] )
 143                 fromfilep = &fromfile;
 144         else
 145                 fromfilep = NULL;
 146         err = UpdateAlias(fromfilep, &target, self->alias, &changed);
 147         if ( err ) {
 148                 PyErr_Mac(ErrorObject, err);
 149                 return 0;
 150         }
 151         return mkvalue("i", (int)changed);
 152 }
 153
 154 static struct methodlist mfsa_methods[] = {
 155         {"Resolve",     (method)mfsa_Resolve,   1},
 156         {"GetInfo",     (method)mfsa_GetInfo,   1},
 157         {"Update",      (method)mfsa_Update,    1},
 158
 159         {NULL,          NULL}           /* sentinel */
 160 };
 161
 162 /* ---------- */
 163
 164 static object *
 165 mfsa_getattr(self, name)
 166         mfsaobject *self;
 167         char *name;
 168 {
 169         if ( strcmp(name, "data") == 0 ) {
 170                 int size;
 171                 PyObject *rv;
 172
 173                 size = GetHandleSize((Handle)self->alias);
 174                 HLock((Handle)self->alias);
 175                 rv = PyString_FromStringAndSize(*(Handle)self->alias, size);
 176                 HUnlock((Handle)self->alias);
 177                 return rv;
 178         }
 179         return findmethod(mfsa_methods, (object *)self, name);
 180 }
 181
 182 mfsaobject *
 183 newmfsaobject(alias)
 184         AliasHandle alias;
 185 {
 186         mfsaobject *self;
 187
 188         self = NEWOBJ(mfsaobject, &Mfsatype);
 189         if (self == NULL)
 190                 return NULL;
 191         self->alias = alias;
 192         return self;
 193 }
 194
 195
 196 static void
 197 mfsa_dealloc(self)
 198         mfsaobject *self;
 199 {
 200 #if 0
 201         if ( self->alias ) {
 202                 should we do something here?
 203         }
 204 #endif
 205
 206         DEL(self);
 207 }
 208
 209 statichere typeobject Mfsatype = {
 210         OB_HEAD_INIT(&Typetype)
 211         0,                              /*ob_size*/
 212         "Alias",                        /*tp_name*/
 213         sizeof(mfsaobject),             /*tp_basicsize*/
 214         0,                              /*tp_itemsize*/
 215         /* methods */
 216         (destructor)mfsa_dealloc,       /*tp_dealloc*/
 217         (printfunc)0,                   /*tp_print*/
 218         (getattrfunc)mfsa_getattr,      /*tp_getattr*/
 219         (setattrfunc)0,                 /*tp_setattr*/
 220         (cmpfunc)0,                     /*tp_compare*/
 221         (reprfunc)0,                    /*tp_repr*/
 222         0,                              /*tp_as_number*/
 223         0,                              /*tp_as_sequence*/
 224         0,                              /*tp_as_mapping*/
 225         (hashfunc)0,                    /*tp_hash*/
 226 };
 227
 228 /* End of code for Alias objects */
 229 /* -------------------------------------------------------- */
 230
 231 /* ---------------------------------------------------------------- */
 232
 233 static struct methodlist mfsi_methods[] = {
 234
 235         {NULL,          NULL}           /* sentinel */
 236 };
 237
 238 /* ---------- */
 239
 240 static mfsiobject *
 241 newmfsiobject()
 242 {
 243         mfsiobject *self;
 244
 245         self = NEWOBJ(mfsiobject, &Mfsitype);
 246         if (self == NULL)
 247                 return NULL;
 248         memset((char *)&self->finfo, '\0', sizeof(self->finfo));
 249         return self;
 250 }
 251
 252 static void
 253 mfsi_dealloc(self)
 254         mfsiobject *self;
 255 {
 256         DEL(self);
 257 }
 258
 259 static object *
 260 mfsi_getattr(self, name)
 261         mfsiobject *self;
 262         char *name;
 263 {
 264         if ( strcmp(name, "Type") == 0 )
 265                 return PyMac_BuildOSType(self->finfo.fdType);
 266         else if ( strcmp(name, "Creator") == 0 )
 267                 return PyMac_BuildOSType(self->finfo.fdCreator);
 268         else if ( strcmp(name, "Flags") == 0 )
 269                 return Py_BuildValue("i", (int)self->finfo.fdFlags);
 270         else if ( strcmp(name, "Location") == 0 )
 271                 return PyMac_BuildPoint(self->finfo.fdLocation);
 272         else if ( strcmp(name, "Fldr") == 0 )
 273                 return Py_BuildValue("i", (int)self->finfo.fdFldr);
 274         else
 275                 return findmethod(mfsi_methods, (object *)self, name);
 276 }
 277
 278
 279 static int
 280 mfsi_setattr(self, name, v)
 281         mfsiobject *self;
 282         char *name;
 283         object *v;
 284 {
 285         int rv;
 286         int i;
 287
 288         if ( v == NULL ) {
 289                 err_setstr(AttributeError, "Cannot delete attribute");
 290                 return -1;
 291         }
 292         if ( strcmp(name, "Type") == 0 )
 293                 rv = PyMac_GetOSType(v, &self->finfo.fdType);
 294         else if ( strcmp(name, "Creator") == 0 )
 295                 rv = PyMac_GetOSType(v, &self->finfo.fdCreator);
 296         else if ( strcmp(name, "Flags") == 0 ) {
 297                 rv = PyArg_Parse(v, "i", &i);
 298                 self->finfo.fdFlags = (short)i;
 299         } else if ( strcmp(name, "Location") == 0 )
 300                 rv = PyMac_GetPoint(v, &self->finfo.fdLocation);
 301         else if ( strcmp(name, "Fldr") == 0 ) {
 302                 rv = PyArg_Parse(v, "i", &i);
 303                 self->finfo.fdFldr = (short)i;
 304         } else {
 305                 err_setstr(AttributeError, "No such attribute");
 306                 return -1;
 307         }
 308         if (rv)
 309                 return 0;
 310         return -1;
 311 }
 312
 313
 314 static typeobject Mfsitype = {
 315         OB_HEAD_INIT(&Typetype)
 316         0,                              /*ob_size*/
 317         "FInfo object",                 /*tp_name*/
 318         sizeof(mfsiobject),             /*tp_basicsize*/
 319         0,                              /*tp_itemsize*/
 320         /* methods */
 321         (destructor)mfsi_dealloc,       /*tp_dealloc*/
 322         (printfunc)0,           /*tp_print*/
 323         (getattrfunc)mfsi_getattr,      /*tp_getattr*/
 324         (setattrfunc)mfsi_setattr,      /*tp_setattr*/
 325         (cmpfunc)0,             /*tp_compare*/
 326         (reprfunc)0,            /*tp_repr*/
 327         0,                      /*tp_as_number*/
 328         0,              /*tp_as_sequence*/
 329         0,              /*tp_as_mapping*/
 330         (hashfunc)0,            /*tp_hash*/
 331 };
 332
 333 /* End of code for FInfo object objects */
 334 /* -------------------------------------------------------- */
 335
 336
 337 /*
 338 ** Helper routine for other modules: return an FSSpec * if the
 339 ** object is a python fsspec object, else NULL
 340 */
 341 FSSpec *
 342 mfs_GetFSSpecFSSpec(self)
 343         object *self;
 344 {
 345         if ( is_mfssobject(self) )
 346                 return &((mfssobject *)self)->fsspec;
 347         return NULL;
 348 }
 349
 350 static object *
 351 mfss_as_pathname(self, args)
 352         mfssobject *self;
 353         object *args;
 354 {
 355         char strbuf[257];
 356         OSErr err;
 357
 358         if (!newgetargs(args, ""))
 359                 return NULL;
 360         err = nfullpath(&self->fsspec, strbuf);
 361         if ( err ) {
 362                 PyErr_Mac(ErrorObject, err);
 363                 return NULL;
 364         }
 365         return newstringobject(strbuf);
 366 }
 367
 368 static object *
 369 mfss_as_tuple(self, args)
 370         mfssobject *self;
 371         object *args;
 372 {
 373         if (!newgetargs(args, ""))
 374                 return NULL;
 375         return Py_BuildValue("(iis#)", self->fsspec.vRefNum, self->fsspec.parID,
 376                                                 &self->fsspec.name[1], self->fsspec.name[0]);
 377 }
 378
 379 static object *
 380 mfss_NewAlias(self, args)
 381         mfssobject *self;
 382         object *args;
 383 {
 384         FSSpec src, *srcp;
 385         OSErr err;
 386         AliasHandle alias;
 387
 388         src.name[0] = 0;
 389         if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &src))
 390                 return NULL;
 391         if ( src.name[0] )
 392                 srcp = &src;
 393         else
 394                 srcp = NULL;
 395         err = NewAlias(srcp, &self->fsspec, &alias);
 396         if ( err ) {
 397                 PyErr_Mac(ErrorObject, err);
 398                 return NULL;
 399         }
 400
 401         return (object *)newmfsaobject(alias);
 402 }
 403
 404 static object *
 405 mfss_NewAliasMinimal(self, args)
 406         mfssobject *self;
 407         object *args;
 408 {
 409         OSErr err;
 410         AliasHandle alias;
 411
 412         if (!newgetargs(args, ""))
 413                 return NULL;
 414         err = NewAliasMinimal(&self->fsspec, &alias);
 415         if ( err ) {
 416                 PyErr_Mac(ErrorObject, err);
 417                 return NULL;
 418         }
 419         return (object *)newmfsaobject(alias);
 420 }
 421
 422 /* XXXX These routines should be replaced by a wrapper to the *FInfo routines */
 423 static object *
 424 mfss_GetCreatorType(self, args)
 425         mfssobject *self;
 426         object *args;
 427 {
 428         OSErr err;
 429         FInfo info;
 430
 431         if (!newgetargs(args, ""))
 432                 return NULL;
 433         err = FSpGetFInfo(&self->fsspec, &info);
 434         if ( err ) {
 435                 PyErr_Mac(ErrorObject, err);
 436                 return NULL;
 437         }
 438         return Py_BuildValue("(O&O&)",
 439                    PyMac_BuildOSType, info.fdCreator, PyMac_BuildOSType, info.fdType);
 440 }
 441
 442 static object *
 443 mfss_SetCreatorType(self, args)
 444         mfssobject *self;
 445         object *args;
 446 {
 447         OSErr err;
 448         OSType creator, type;
 449         FInfo info;
 450
 451         if (!newgetargs(args, "O&O&", PyMac_GetOSType, &creator, PyMac_GetOSType, &type))
 452                 return NULL;
 453         err = FSpGetFInfo(&self->fsspec, &info);
 454         if ( err ) {
 455                 PyErr_Mac(ErrorObject, err);
 456                 return NULL;
 457         }
 458         info.fdType = type;
 459         info.fdCreator = creator;
 460         err = FSpSetFInfo(&self->fsspec, &info);
 461         if ( err ) {
 462                 PyErr_Mac(ErrorObject, err);
 463                 return NULL;
 464         }
 465         INCREF(None);
 466         return None;
 467 }
 468
 469 static object *
 470 mfss_GetFInfo(self, args)
 471         mfssobject *self;
 472         object *args;
 473 {
 474         OSErr err;
 475         mfsiobject *fip;
 476
 477
 478         if (!newgetargs(args, ""))
 479                 return NULL;
 480         if ( (fip=newmfsiobject()) == NULL )
 481                 return NULL;
 482         err = FSpGetFInfo(&self->fsspec, &fip->finfo);
 483         if ( err ) {
 484                 PyErr_Mac(ErrorObject, err);
 485                 DECREF(fip);
 486                 return NULL;
 487         }
 488         return (object *)fip;
 489 }
 490
 491 static object *
 492 mfss_SetFInfo(self, args)
 493         mfssobject *self;
 494         object *args;
 495 {
 496         OSErr err;
 497         mfsiobject *fip;
 498
 499         if (!newgetargs(args, "O!", &Mfsitype, &fip))
 500                 return NULL;
 501         err = FSpSetFInfo(&self->fsspec, &fip->finfo);
 502         if ( err ) {
 503                 PyErr_Mac(ErrorObject, err);
 504                 return NULL;
 505         }
 506         INCREF(None);
 507         return None;
 508 }
 509
 510 static struct methodlist mfss_methods[] = {
 511         {"as_pathname",         (method)mfss_as_pathname,                       1},
 512         {"as_tuple",            (method)mfss_as_tuple,                          1},
 513         {"NewAlias",            (method)mfss_NewAlias,                          1},
 514         {"NewAliasMinimal",     (method)mfss_NewAliasMinimal,           1},
 515         {"GetCreatorType",      (method)mfss_GetCreatorType,            1},
 516         {"SetCreatorType",      (method)mfss_SetCreatorType,            1},
 517         {"GetFInfo",            (method)mfss_GetFInfo,                          1},
 518         {"SetFInfo",            (method)mfss_SetFInfo,                          1},
 519
 520         {NULL,                  NULL}           /* sentinel */
 521 };
 522
 523 /* ---------- */
 524
 525 static object *
 526 mfss_getattr(self, name)
 527         mfssobject *self;
 528         char *name;
 529 {
 530         if ( strcmp(name, "data") == 0)
 531                 return PyString_FromStringAndSize((char *)&self->fsspec, sizeof(FSSpec));
 532         return findmethod(mfss_methods, (object *)self, name);
 533 }
 534
 535 mfssobject *
 536 newmfssobject(fss)
 537         FSSpec *fss;
 538 {
 539         mfssobject *self;
 540
 541         self = NEWOBJ(mfssobject, &Mfsstype);
 542         if (self == NULL)
 543                 return NULL;
 544         self->fsspec = *fss;
 545         return self;
 546 }
 547
 548 static void
 549 mfss_dealloc(self)
 550         mfssobject *self;
 551 {
 552         DEL(self);
 553 }
 554
 555 static object *
 556 mfss_repr(self)
 557         mfssobject *self;
 558 {
 559         char buf[512];
 560
 561         sprintf(buf, "FSSpec((%d, %d, '%.*s'))",
 562                 self->fsspec.vRefNum,
 563                 self->fsspec.parID,
 564                 self->fsspec.name[0], self->fsspec.name+1);
 565         return newstringobject(buf);
 566 }
 567
 568 static int
 569 mfss_compare(v, w)
 570         mfssobject *v, *w;
 571 {
 572         int minlen;
 573         int res;
 574
 575         if ( v->fsspec.vRefNum < w->fsspec.vRefNum ) return -1;
 576         if ( v->fsspec.vRefNum > w->fsspec.vRefNum ) return 1;
 577         if ( v->fsspec.parID < w->fsspec.parID ) return -1;
 578         if ( v->fsspec.parID > w->fsspec.parID ) return 1;
 579         minlen = v->fsspec.name[0];
 580         if ( w->fsspec.name[0] < minlen ) minlen = w->fsspec.name[0];
 581         res = strncmp((char *)v->fsspec.name+1, (char *)w->fsspec.name+1, minlen);
 582         if ( res ) return res;
 583         if ( v->fsspec.name[0] < w->fsspec.name[0] ) return -1;
 584         if ( v->fsspec.name[0] > w->fsspec.name[0] ) return 1;
 585         return res;
 586 }
 587
 588 statichere typeobject Mfsstype = {
 589         OB_HEAD_INIT(&Typetype)
 590         0,                              /*ob_size*/
 591         "FSSpec",                       /*tp_name*/
 592         sizeof(mfssobject),             /*tp_basicsize*/
 593         0,                              /*tp_itemsize*/
 594         /* methods */
 595         (destructor)mfss_dealloc,       /*tp_dealloc*/
 596         (printfunc)0,           /*tp_print*/
 597         (getattrfunc)mfss_getattr,      /*tp_getattr*/
 598         (setattrfunc)0, /*tp_setattr*/
 599         (cmpfunc)mfss_compare,          /*tp_compare*/
 600         (reprfunc)mfss_repr,            /*tp_repr*/
 601         0,                      /*tp_as_number*/
 602         0,              /*tp_as_sequence*/
 603         0,              /*tp_as_mapping*/
 604         (hashfunc)0,            /*tp_hash*/
 605 };
 606
 607 /* End of code for FSSpec objects */
 608 /* -------------------------------------------------------- */
 609
 610 static object *
 611 mfs_ResolveAliasFile(self, args)
 612         object *self;   /* Not used */
 613         object *args;
 614 {
 615         FSSpec fss;
 616         Boolean chain = 1, isfolder, wasaliased;
 617         OSErr err;
 618
 619         if (!newgetargs(args, "O&|i", PyMac_GetFSSpec, &fss, &chain))
 620                 return NULL;
 621         err = ResolveAliasFile(&fss, chain, &isfolder, &wasaliased);
 622         if ( err ) {
 623                 PyErr_Mac(ErrorObject, err);
 624                 return NULL;
 625         }
 626         return mkvalue("Oii", newmfssobject(&fss), (int)isfolder, (int)wasaliased);
 627 }
 628
 629 static object *
 630 mfs_StandardGetFile(self, args)
 631         object *self;   /* Not used */
 632         object *args;
 633 {
 634         SFTypeList list;
 635         short numtypes;
 636         StandardFileReply reply;
 637
 638         list[0] = list[1] = list[2] = list[3] = 0;
 639         numtypes = 0;
 640         if (!newgetargs(args, "|O&O&O&O&", PyMac_GetOSType, &list[0],
 641                          PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
 642                           PyMac_GetOSType, &list[3]) )
 643                 return NULL;
 644         while ( numtypes < 4 && list[numtypes] ) {
 645                 numtypes++;
 646         }
 647         if ( numtypes == 0 )
 648                 numtypes = -1;
 649         StandardGetFile((FileFilterUPP)0, numtypes, list, &reply);
 650         return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
 651 }
 652
 653 static object *
 654 mfs_PromptGetFile(self, args)
 655         object *self;   /* Not used */
 656         object *args;
 657 {
 658         SFTypeList list;
 659         short numtypes;
 660         StandardFileReply reply;
 661         char *prompt = NULL;
 662
 663         list[0] = list[1] = list[2] = list[3] = 0;
 664         numtypes = 0;
 665         if (!newgetargs(args, "s|O&O&O&O&", &prompt, PyMac_GetOSType, &list[0],
 666                          PyMac_GetOSType, &list[1], PyMac_GetOSType, &list[2],
 667                           PyMac_GetOSType, &list[3]) )
 668                 return NULL;
 669         while ( numtypes < 4 && list[numtypes] ) {
 670                 numtypes++;
 671         }
 672         if ( numtypes == 0 )
 673                 numtypes = -1;
 674         PyMac_PromptGetFile(numtypes, list, &reply, prompt);
 675         return mkvalue("(Oi)", newmfssobject(&reply.sfFile), reply.sfGood);
 676 }
 677
 678 static object *
 679 mfs_StandardPutFile(self, args)
 680         object *self;   /* Not used */
 681         object *args;
 682 {
 683         Str255 prompt, dft;
 684         StandardFileReply reply;
 685
 686         dft[0] = 0;
 687         if (!newgetargs(args, "O&|O&", PyMac_GetStr255, &prompt, PyMac_GetStr255, &dft) )
 688                 return NULL;
 689         StandardPutFile(prompt, dft, &reply);
 690         return mkvalue("(Oi)",newmfssobject(&reply.sfFile), reply.sfGood);
 691 }
 692
 693 /*
 694 ** Set initial directory for file dialogs */
 695 static object *
 696 mfs_SetFolder(self, args)
 697         object *self;
 698         object *args;
 699 {
 700         FSSpec spec;
 701         FSSpec ospec;
 702         short orefnum;
 703         long oparid;
 704
 705         /* Get old values */
 706         orefnum = -LMGetSFSaveDisk();
 707         oparid = LMGetCurDirStore();
 708         (void)FSMakeFSSpec(orefnum, oparid, "\pplaceholder", &ospec);
 709
 710         /* Go to working directory by default */
 711         (void)FSMakeFSSpec(0, 0, "\p:placeholder", &spec);
 712         if (!newgetargs(args, "|O&", PyMac_GetFSSpec, &spec))
 713                 return NULL;
 714         /* Set standard-file working directory */
 715         LMSetSFSaveDisk(-spec.vRefNum);
 716         LMSetCurDirStore(spec.parID);
 717         return (object *)newmfssobject(&ospec);
 718 }
 719
 720 static object *
 721 mfs_FSSpec(self, args)
 722         object *self;   /* Not used */
 723         object *args;
 724 {
 725         FSSpec fss;
 726
 727         if (!newgetargs(args, "O&", PyMac_GetFSSpec, &fss))
 728                 return NULL;
 729         return (object *)newmfssobject(&fss);
 730 }
 731
 732 static object *
 733 mfs_RawFSSpec(self, args)
 734         object *self;   /* Not used */
 735         object *args;
 736 {
 737         FSSpec *fssp;
 738         int size;
 739
 740         if (!newgetargs(args, "s#", &fssp, &size))
 741                 return NULL;
 742         if ( size != sizeof(FSSpec) ) {
 743                 PyErr_SetString(PyExc_TypeError, "Incorrect size for FSSpec record");
 744                 return NULL;
 745         }
 746         return (object *)newmfssobject(fssp);
 747 }
 748
 749 static object *
 750 mfs_RawAlias(self, args)
 751         object *self;   /* Not used */
 752         object *args;
 753 {
 754         char *dataptr;
 755         Handle h;
 756         int size;
 757
 758         if (!newgetargs(args, "s#", &dataptr, &size))
 759                 return NULL;
 760         h = NewHandle(size);
 761         if ( h == NULL ) {
 762                 PyErr_NoMemory();
 763                 return NULL;
 764         }
 765         HLock(h);
 766         memcpy((char *)*h, dataptr, size);
 767         HUnlock(h);
 768         return (object *)newmfsaobject((AliasHandle)h);
 769 }
 770
 771 static object *
 772 mfs_GetDirectory(self, args)
 773         object *self;   /* Not used */
 774         object *args;
 775 {
 776         FSSpec fsdir;
 777         int ok;
 778         char *prompt = NULL;
 779
 780         if (!newgetargs(args, "|s", &prompt) )
 781                 return NULL;
 782
 783         ok = PyMac_GetDirectory(&fsdir, prompt);
 784         return mkvalue("(Oi)", newmfssobject(&fsdir), ok);
 785 }
 786
 787 static object *
 788 mfs_FindFolder(self, args)
 789         object *self;   /* Not used */
 790         object *args;
 791 {
 792         OSErr err;
 793         short where;
 794         OSType which;
 795         int create;
 796         short refnum;
 797         long dirid;
 798
 799         if (!newgetargs(args, "hO&i", &where, PyMac_GetOSType, &which, &create) )
 800                 return NULL;
 801         err = FindFolder(where, which, (Boolean)create, &refnum, &dirid);
 802         if ( err ) {
 803                 PyErr_Mac(ErrorObject, err);
 804                 return NULL;
 805         }
 806         return mkvalue("(ii)", refnum, dirid);
 807 }
 808
 809 static object *
 810 mfs_FInfo(self, args)
 811         object *self;
 812         object *args;
 813 {
 814         return (object *)newmfsiobject();
 815 }
 816
 817 /* List of methods defined in the module */
 818
 819 static struct methodlist mfs_methods[] = {
 820         {"ResolveAliasFile",    mfs_ResolveAliasFile,   1},
 821         {"StandardGetFile",             mfs_StandardGetFile,    1},
 822         {"PromptGetFile",               mfs_PromptGetFile,              1},
 823         {"StandardPutFile",             mfs_StandardPutFile,    1},
 824         {"GetDirectory",                mfs_GetDirectory,               1},
 825         {"SetFolder",                   mfs_SetFolder,                  1},
 826         {"FSSpec",                              mfs_FSSpec,                             1},
 827         {"RawFSSpec",                   mfs_RawFSSpec,                  1},
 828         {"RawAlias",                    mfs_RawAlias,                   1},
 829         {"FindFolder",                  mfs_FindFolder,                 1},
 830         {"FInfo",                               mfs_FInfo,                              1},
 831
 832         {NULL,          NULL}           /* sentinel */
 833 };
 834
 835
 836 /* Initialization function for the module (*must* be called initmacfs) */
 837
 838 void
 839 initmacfs()
 840 {
 841         object *m, *d;
 842
 843         /* Create the module and add the functions */
 844         m = initmodule("macfs", mfs_methods);
 845
 846         /* Add some symbolic constants to the module */
 847         d = getmoduledict(m);
 848         ErrorObject = newstringobject("macfs.error");
 849         dictinsert(d, "error", ErrorObject);
 850
 851         /* XXXX Add constants here */
 852
 853         /* Check for errors */
 854         if (err_occurred())
 855                 fatal("can't initialize module macfs");
 856 }