1 2 /* ========================== Module _File ========================== */ 3 4 #include "Python.h" 5 6 7 8 #include "pymactoolbox.h" 9 10 #ifndef HAVE_OSX105_SDK 11 typedef SInt16 FSIORefNum; 12 #endif 13 14 /* Macro to test whether a weak-loaded CFM function exists */ 15 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ 16 PyErr_SetString(PyExc_NotImplementedError, \ 17 "Not available in this shared library/OS version"); \ 18 return NULL; \ 19 }} while(0) 20 21 22 #include <Carbon/Carbon.h> 23 24 #ifdef USE_TOOLBOX_OBJECT_GLUE 25 26 #ifndef __LP64__ 27 extern int _PyMac_GetFSSpec(PyObject *v, FSSpec *spec); 28 extern PyObject *_PyMac_BuildFSSpec(FSSpec *spec); 29 #define PyMac_BuildFSSpec _PyMac_BuildFSSpec 30 #endif /* __LP64__*/ 31 32 extern int _PyMac_GetFSRef(PyObject *v, FSRef *fsr); 33 extern PyObject *_PyMac_BuildFSRef(FSRef *spec); 34 #define PyMac_BuildFSRef _PyMac_BuildFSRef 35 #define PyMac_GetFSSpec _PyMac_GetFSSpec 36 #define PyMac_GetFSRef _PyMac_GetFSRef 37 38 #else /* !USE_TOOLBOX_OBJECT_GLUE */ 39 40 #ifndef __LP64__ 41 extern int PyMac_GetFSSpec(PyObject *v, FSSpec *spec); 42 extern PyObject *PyMac_BuildFSSpec(FSSpec *spec); 43 #endif /* !__LP64__*/ 44 45 extern int PyMac_GetFSRef(PyObject *v, FSRef *fsr); 46 extern PyObject *PyMac_BuildFSRef(FSRef *spec); 47 48 #endif /* !USE_TOOLBOX_OBJECT_GLUE */ 49 50 /* Forward declarations */ 51 static PyObject *FSRef_New(FSRef *itself); 52 #ifndef __LP64__ 53 static PyObject *FInfo_New(FInfo *itself); 54 55 static PyObject *FSSpec_New(FSSpec *itself); 56 #define FSSpec_Convert PyMac_GetFSSpec 57 #endif /* !__LP64__ */ 58 59 static PyObject *Alias_New(AliasHandle itself); 60 #ifndef __LP64__ 61 static int FInfo_Convert(PyObject *v, FInfo *p_itself); 62 #endif /* !__LP64__ */ 63 #define FSRef_Convert PyMac_GetFSRef 64 static int Alias_Convert(PyObject *v, AliasHandle *p_itself); 65 66 /* 67 ** UTCDateTime records 68 */ 69 static int 70 UTCDateTime_Convert(PyObject *v, UTCDateTime *ptr) 71 { 72 return PyArg_Parse(v, "(HlH)", &ptr->highSeconds, &ptr->lowSeconds, &ptr->fraction); 73 } 74 75 static PyObject * 76 UTCDateTime_New(UTCDateTime *ptr) 77 { 78 return Py_BuildValue("(HlH)", ptr->highSeconds, ptr->lowSeconds, ptr->fraction); 79 } 80 81 /* 82 ** Optional fsspec and fsref pointers. None will pass NULL 83 */ 84 #ifndef __LP64__ 85 static int 86 myPyMac_GetOptFSSpecPtr(PyObject *v, FSSpec **spec) 87 { 88 if (v == Py_None) { 89 *spec = NULL; 90 return 1; 91 } 92 return PyMac_GetFSSpec(v, *spec); 93 } 94 #endif /* !__LP64__ */ 95 96 static int 97 myPyMac_GetOptFSRefPtr(PyObject *v, FSRef **ref) 98 { 99 if (v == Py_None) { 100 *ref = NULL; 101 return 1; 102 } 103 return PyMac_GetFSRef(v, *ref); 104 } 105 106 /* 107 ** Parse/generate objsect 108 */ 109 static PyObject * 110 PyMac_BuildHFSUniStr255(HFSUniStr255 *itself) 111 { 112 113 return Py_BuildValue("u#", itself->unicode, itself->length); 114 } 115 116 #ifndef __LP64__ 117 static OSErr 118 _PyMac_GetFullPathname(FSSpec *fss, char *path, int len) 119 { 120 FSRef fsr; 121 OSErr err; 122 123 *path = '\0'; 124 err = FSpMakeFSRef(fss, &fsr); 125 if (err == fnfErr) { 126 /* FSSpecs can point to non-existing files, fsrefs can't. */ 127 FSSpec fss2; 128 int tocopy; 129 130 err = FSMakeFSSpec(fss->vRefNum, fss->parID, 131 (unsigned char*)"", &fss2); 132 if (err) 133 return err; 134 err = FSpMakeFSRef(&fss2, &fsr); 135 if (err) 136 return err; 137 err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len-1); 138 if (err) 139 return err; 140 /* This part is not 100% safe: we append the filename part, but 141 ** I'm not sure that we don't run afoul of the various 8bit 142 ** encodings here. Will have to look this up at some point... 143 */ 144 strcat(path, "/"); 145 tocopy = fss->name[0]; 146 if ((strlen(path) + tocopy) >= len) 147 tocopy = len - strlen(path) - 1; 148 if (tocopy > 0) 149 strncat(path, (char*)fss->name+1, tocopy); 150 } 151 else { 152 if (err) 153 return err; 154 err = (OSErr)FSRefMakePath(&fsr, (unsigned char*)path, len); 155 if (err) 156 return err; 157 } 158 return 0; 159 } 160 #endif /* !__LP64__ */ 161 162 163 static PyObject *File_Error; 164 165 /* ------------------- Object type FSCatalogInfo -------------------- */ 166 167 static PyTypeObject FSCatalogInfo_Type; 168 169 #define FSCatalogInfo_Check(x) ((x)->ob_type == &FSCatalogInfo_Type || PyObject_TypeCheck((x), &FSCatalogInfo_Type)) 170 171 typedef struct FSCatalogInfoObject { 172 PyObject_HEAD 173 FSCatalogInfo ob_itself; 174 } FSCatalogInfoObject; 175 176 static PyObject *FSCatalogInfo_New(FSCatalogInfo *itself) 177 { 178 FSCatalogInfoObject *it; 179 if (itself == NULL) { Py_INCREF(Py_None); return Py_None; } 180 it = PyObject_NEW(FSCatalogInfoObject, &FSCatalogInfo_Type); 181 if (it == NULL) return NULL; 182 it->ob_itself = *itself; 183 return (PyObject *)it; 184 } 185 186 static int FSCatalogInfo_Convert(PyObject *v, FSCatalogInfo *p_itself) 187 { 188 if (!FSCatalogInfo_Check(v)) 189 { 190 PyErr_SetString(PyExc_TypeError, "FSCatalogInfo required"); 191 return 0; 192 } 193 *p_itself = ((FSCatalogInfoObject *)v)->ob_itself; 194 return 1; 195 } 196 197 static void FSCatalogInfo_dealloc(FSCatalogInfoObject *self) 198 { 199 /* Cleanup of self->ob_itself goes here */ 200 self->ob_type->tp_free((PyObject *)self); 201 } 202 203 static PyMethodDef FSCatalogInfo_methods[] = { 204 {NULL, NULL, 0} 205 }; 206 207 static PyObject *FSCatalogInfo_get_nodeFlags(FSCatalogInfoObject *self, void *closure) 208 { 209 return Py_BuildValue("H", self->ob_itself.nodeFlags); 210 } 211 212 static int FSCatalogInfo_set_nodeFlags(FSCatalogInfoObject *self, PyObject *v, void *closure) 213 { 214 return PyArg_Parse(v, "H", &self->ob_itself.nodeFlags)-1; 215 return 0; 216 } 217 218 static PyObject *FSCatalogInfo_get_volume(FSCatalogInfoObject *self, void *closure) 219 { 220 return Py_BuildValue("h", self->ob_itself.volume); 221 } 222 223 static int FSCatalogInfo_set_volume(FSCatalogInfoObject *self, PyObject *v, void *closure) 224 { 225 return PyArg_Parse(v, "h", &self->ob_itself.volume)-1; 226 return 0; 227 } 228 229 static PyObject *FSCatalogInfo_get_parentDirID(FSCatalogInfoObject *self, void *closure) 230 { 231 return Py_BuildValue("l", self->ob_itself.parentDirID); 232 } 233 234 static int FSCatalogInfo_set_parentDirID(FSCatalogInfoObject *self, PyObject *v, void *closure) 235 { 236 return PyArg_Parse(v, "l", &self->ob_itself.parentDirID)-1; 237 return 0; 238 } 239 240 static PyObject *FSCatalogInfo_get_nodeID(FSCatalogInfoObject *self, void *closure) 241 { 242 return Py_BuildValue("l", self->ob_itself.nodeID); 243 } 244 245 static int FSCatalogInfo_set_nodeID(FSCatalogInfoObject *self, PyObject *v, void *closure) 246 { 247 return PyArg_Parse(v, "l", &self->ob_itself.nodeID)-1; 248 return 0; 249 } 250 251 static PyObject *FSCatalogInfo_get_createDate(FSCatalogInfoObject *self, void *closure) 252 { 253 return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.createDate); 254 } 255 256 static int FSCatalogInfo_set_createDate(FSCatalogInfoObject *self, PyObject *v, void *closure) 257 { 258 return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.createDate)-1; 259 return 0; 260 } 261 262 static PyObject *FSCatalogInfo_get_contentModDate(FSCatalogInfoObject *self, void *closure) 263 { 264 return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.contentModDate); 265 } 266 267 static int FSCatalogInfo_set_contentModDate(FSCatalogInfoObject *self, PyObject *v, void *closure) 268 { 269 return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.contentModDate)-1; 270 return 0; 271 } 272 273 static PyObject *FSCatalogInfo_get_attributeModDate(FSCatalogInfoObject *self, void *closure) 274 { 275 return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.attributeModDate); 276 } 277 278 static int FSCatalogInfo_set_attributeModDate(FSCatalogInfoObject *self, PyObject *v, void *closure) 279 { 280 return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.attributeModDate)-1; 281 return 0; 282 } 283 284 static PyObject *FSCatalogInfo_get_accessDate(FSCatalogInfoObject *self, void *closure) 285 { 286 return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.accessDate); 287 } 288 289 static int FSCatalogInfo_set_accessDate(FSCatalogInfoObject *self, PyObject *v, void *closure) 290 { 291 return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.accessDate)-1; 292 return 0; 293 } 294 295 static PyObject *FSCatalogInfo_get_backupDate(FSCatalogInfoObject *self, void *closure) 296 { 297 return Py_BuildValue("O&", UTCDateTime_New, &self->ob_itself.backupDate); 298 } 299 300 static int FSCatalogInfo_set_backupDate(FSCatalogInfoObject *self, PyObject *v, void *closure) 301 { 302 return PyArg_Parse(v, "O&", UTCDateTime_Convert, &self->ob_itself.backupDate)-1; 303 return 0; 304 } 305 306 static PyObject *FSCatalogInfo_get_permissions(FSCatalogInfoObject *self, void *closure) 307 { 308 FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions); 309 return Py_BuildValue("(llll)", info->userID, info->groupID, info->userAccess, info->mode); 310 } 311 312 static int FSCatalogInfo_set_permissions(FSCatalogInfoObject *self, PyObject *v, void *closure) 313 { 314 long userID; 315 long groupID; 316 long userAccess; 317 long mode; 318 int r; 319 320 FSPermissionInfo* info = (FSPermissionInfo*)&(self->ob_itself.permissions); 321 322 r = PyArg_Parse(v, "(llll)", &userID, &groupID, &userAccess, &mode); 323 if (!r) { 324 return -1; 325 } 326 info->userID = userID; 327 info->groupID = groupID; 328 info->userAccess = userAccess; 329 info->mode = mode; 330 return 0; 331 } 332 333 static PyObject *FSCatalogInfo_get_valence(FSCatalogInfoObject *self, void *closure) 334 { 335 return Py_BuildValue("l", self->ob_itself.valence); 336 } 337 338 static int FSCatalogInfo_set_valence(FSCatalogInfoObject *self, PyObject *v, void *closure) 339 { 340 return PyArg_Parse(v, "l", &self->ob_itself.valence)-1; 341 return 0; 342 } 343 344 static PyObject *FSCatalogInfo_get_dataLogicalSize(FSCatalogInfoObject *self, void *closure) 345 { 346 return Py_BuildValue("l", self->ob_itself.dataLogicalSize); 347 } 348 349 static int FSCatalogInfo_set_dataLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure) 350 { 351 return PyArg_Parse(v, "l", &self->ob_itself.dataLogicalSize)-1; 352 return 0; 353 } 354 355 static PyObject *FSCatalogInfo_get_dataPhysicalSize(FSCatalogInfoObject *self, void *closure) 356 { 357 return Py_BuildValue("l", self->ob_itself.dataPhysicalSize); 358 } 359 360 static int FSCatalogInfo_set_dataPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure) 361 { 362 return PyArg_Parse(v, "l", &self->ob_itself.dataPhysicalSize)-1; 363 return 0; 364 } 365 366 static PyObject *FSCatalogInfo_get_rsrcLogicalSize(FSCatalogInfoObject *self, void *closure) 367 { 368 return Py_BuildValue("l", self->ob_itself.rsrcLogicalSize); 369 } 370 371 static int FSCatalogInfo_set_rsrcLogicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure) 372 { 373 return PyArg_Parse(v, "l", &self->ob_itself.rsrcLogicalSize)-1; 374 return 0; 375 } 376 377 static PyObject *FSCatalogInfo_get_rsrcPhysicalSize(FSCatalogInfoObject *self, void *closure) 378 { 379 return Py_BuildValue("l", self->ob_itself.rsrcPhysicalSize); 380 } 381 382 static int FSCatalogInfo_set_rsrcPhysicalSize(FSCatalogInfoObject *self, PyObject *v, void *closure) 383 { 384 return PyArg_Parse(v, "l", &self->ob_itself.rsrcPhysicalSize)-1; 385 return 0; 386 } 387 388 static PyObject *FSCatalogInfo_get_sharingFlags(FSCatalogInfoObject *self, void *closure) 389 { 390 return Py_BuildValue("l", self->ob_itself.sharingFlags); 391 } 392 393 static int FSCatalogInfo_set_sharingFlags(FSCatalogInfoObject *self, PyObject *v, void *closure) 394 { 395 return PyArg_Parse(v, "l", &self->ob_itself.sharingFlags)-1; 396 return 0; 397 } 398 399 static PyObject *FSCatalogInfo_get_userPrivileges(FSCatalogInfoObject *self, void *closure) 400 { 401 return Py_BuildValue("b", self->ob_itself.userPrivileges); 402 } 403 404 static int FSCatalogInfo_set_userPrivileges(FSCatalogInfoObject *self, PyObject *v, void *closure) 405 { 406 return PyArg_Parse(v, "b", &self->ob_itself.userPrivileges)-1; 407 return 0; 408 } 409 410 static PyGetSetDef FSCatalogInfo_getsetlist[] = { 411 {"nodeFlags", (getter)FSCatalogInfo_get_nodeFlags, (setter)FSCatalogInfo_set_nodeFlags, NULL}, 412 {"volume", (getter)FSCatalogInfo_get_volume, (setter)FSCatalogInfo_set_volume, NULL}, 413 {"parentDirID", (getter)FSCatalogInfo_get_parentDirID, (setter)FSCatalogInfo_set_parentDirID, NULL}, 414 {"nodeID", (getter)FSCatalogInfo_get_nodeID, (setter)FSCatalogInfo_set_nodeID, NULL}, 415 {"createDate", (getter)FSCatalogInfo_get_createDate, (setter)FSCatalogInfo_set_createDate, NULL}, 416 {"contentModDate", (getter)FSCatalogInfo_get_contentModDate, (setter)FSCatalogInfo_set_contentModDate, NULL}, 417 {"attributeModDate", (getter)FSCatalogInfo_get_attributeModDate, (setter)FSCatalogInfo_set_attributeModDate, NULL}, 418 {"accessDate", (getter)FSCatalogInfo_get_accessDate, (setter)FSCatalogInfo_set_accessDate, NULL}, 419 {"backupDate", (getter)FSCatalogInfo_get_backupDate, (setter)FSCatalogInfo_set_backupDate, NULL}, 420 {"permissions", (getter)FSCatalogInfo_get_permissions, (setter)FSCatalogInfo_set_permissions, NULL}, 421 {"valence", (getter)FSCatalogInfo_get_valence, (setter)FSCatalogInfo_set_valence, NULL}, 422 {"dataLogicalSize", (getter)FSCatalogInfo_get_dataLogicalSize, (setter)FSCatalogInfo_set_dataLogicalSize, NULL}, 423 {"dataPhysicalSize", (getter)FSCatalogInfo_get_dataPhysicalSize, (setter)FSCatalogInfo_set_dataPhysicalSize, NULL}, 424 {"rsrcLogicalSize", (getter)FSCatalogInfo_get_rsrcLogicalSize, (setter)FSCatalogInfo_set_rsrcLogicalSize, NULL}, 425 {"rsrcPhysicalSize", (getter)FSCatalogInfo_get_rsrcPhysicalSize, (setter)FSCatalogInfo_set_rsrcPhysicalSize, NULL}, 426 {"sharingFlags", (getter)FSCatalogInfo_get_sharingFlags, (setter)FSCatalogInfo_set_sharingFlags, NULL}, 427 {"userPrivileges", (getter)FSCatalogInfo_get_userPrivileges, (setter)FSCatalogInfo_set_userPrivileges, NULL}, 428 {NULL, NULL, NULL, NULL}, 429 }; 430 431 432 #define FSCatalogInfo_compare NULL 433 434 #define FSCatalogInfo_repr NULL 435 436 #define FSCatalogInfo_hash NULL 437 static int FSCatalogInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) 438 { 439 static char *kw[] = { 440 "nodeFlags", 441 "volume", 442 "parentDirID", 443 "nodeID", 444 "createDate", 445 "contentModDate", 446 "atributeModDate", 447 "accessDate", 448 "backupDate", 449 "valence", 450 "dataLogicalSize", 451 "dataPhysicalSize", 452 "rsrcLogicalSize", 453 "rsrcPhysicalSize", 454 "sharingFlags", 455 "userPrivileges" 456 , 0}; 457 458 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|HhllO&O&O&O&O&llllllb", kw, &((FSCatalogInfoObject *)_self)->ob_itself.nodeFlags, 459 &((FSCatalogInfoObject *)_self)->ob_itself.volume, 460 &((FSCatalogInfoObject *)_self)->ob_itself.parentDirID, 461 &((FSCatalogInfoObject *)_self)->ob_itself.nodeID, 462 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.createDate, 463 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.contentModDate, 464 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.attributeModDate, 465 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.accessDate, 466 UTCDateTime_Convert, &((FSCatalogInfoObject *)_self)->ob_itself.backupDate, 467 &((FSCatalogInfoObject *)_self)->ob_itself.valence, 468 &((FSCatalogInfoObject *)_self)->ob_itself.dataLogicalSize, 469 &((FSCatalogInfoObject *)_self)->ob_itself.dataPhysicalSize, 470 &((FSCatalogInfoObject *)_self)->ob_itself.rsrcLogicalSize, 471 &((FSCatalogInfoObject *)_self)->ob_itself.rsrcPhysicalSize, 472 &((FSCatalogInfoObject *)_self)->ob_itself.sharingFlags, 473 &((FSCatalogInfoObject *)_self)->ob_itself.userPrivileges)) 474 { 475 return -1; 476 } 477 return 0; 478 } 479 480 #define FSCatalogInfo_tp_alloc PyType_GenericAlloc 481 482 static PyObject *FSCatalogInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 483 { 484 PyObject *self; 485 486 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; 487 memset(&((FSCatalogInfoObject *)self)->ob_itself, 0, sizeof(FSCatalogInfo)); 488 return self; 489 } 490 491 #define FSCatalogInfo_tp_free PyObject_Del 492 493 494 static PyTypeObject FSCatalogInfo_Type = { 495 PyObject_HEAD_INIT(NULL) 496 0, /*ob_size*/ 497 "Carbon.File.FSCatalogInfo", /*tp_name*/ 498 sizeof(FSCatalogInfoObject), /*tp_basicsize*/ 499 0, /*tp_itemsize*/ 500 /* methods */ 501 (destructor) FSCatalogInfo_dealloc, /*tp_dealloc*/ 502 0, /*tp_print*/ 503 (getattrfunc)0, /*tp_getattr*/ 504 (setattrfunc)0, /*tp_setattr*/ 505 (cmpfunc) FSCatalogInfo_compare, /*tp_compare*/ 506 (reprfunc) FSCatalogInfo_repr, /*tp_repr*/ 507 (PyNumberMethods *)0, /* tp_as_number */ 508 (PySequenceMethods *)0, /* tp_as_sequence */ 509 (PyMappingMethods *)0, /* tp_as_mapping */ 510 (hashfunc) FSCatalogInfo_hash, /*tp_hash*/ 511 0, /*tp_call*/ 512 0, /*tp_str*/ 513 PyObject_GenericGetAttr, /*tp_getattro*/ 514 PyObject_GenericSetAttr, /*tp_setattro */ 515 0, /*tp_as_buffer*/ 516 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 517 0, /*tp_doc*/ 518 0, /*tp_traverse*/ 519 0, /*tp_clear*/ 520 0, /*tp_richcompare*/ 521 0, /*tp_weaklistoffset*/ 522 0, /*tp_iter*/ 523 0, /*tp_iternext*/ 524 FSCatalogInfo_methods, /* tp_methods */ 525 0, /*tp_members*/ 526 FSCatalogInfo_getsetlist, /*tp_getset*/ 527 0, /*tp_base*/ 528 0, /*tp_dict*/ 529 0, /*tp_descr_get*/ 530 0, /*tp_descr_set*/ 531 0, /*tp_dictoffset*/ 532 FSCatalogInfo_tp_init, /* tp_init */ 533 FSCatalogInfo_tp_alloc, /* tp_alloc */ 534 FSCatalogInfo_tp_new, /* tp_new */ 535 FSCatalogInfo_tp_free, /* tp_free */ 536 }; 537 538 /* ----------------- End object type FSCatalogInfo ------------------ */ 539 540 541 /* ----------------------- Object type FInfo ------------------------ */ 542 543 #ifndef __LP64__ 544 545 static PyTypeObject FInfo_Type; 546 547 #define FInfo_Check(x) ((x)->ob_type == &FInfo_Type || PyObject_TypeCheck((x), &FInfo_Type)) 548 549 typedef struct FInfoObject { 550 PyObject_HEAD 551 FInfo ob_itself; 552 } FInfoObject; 553 554 static PyObject *FInfo_New(FInfo *itself) 555 { 556 FInfoObject *it; 557 if (itself == NULL) return PyMac_Error(resNotFound); 558 it = PyObject_NEW(FInfoObject, &FInfo_Type); 559 if (it == NULL) return NULL; 560 it->ob_itself = *itself; 561 return (PyObject *)it; 562 } 563 564 static int FInfo_Convert(PyObject *v, FInfo *p_itself) 565 { 566 if (!FInfo_Check(v)) 567 { 568 PyErr_SetString(PyExc_TypeError, "FInfo required"); 569 return 0; 570 } 571 *p_itself = ((FInfoObject *)v)->ob_itself; 572 return 1; 573 } 574 575 static void FInfo_dealloc(FInfoObject *self) 576 { 577 /* Cleanup of self->ob_itself goes here */ 578 self->ob_type->tp_free((PyObject *)self); 579 } 580 581 static PyMethodDef FInfo_methods[] = { 582 {NULL, NULL, 0} 583 }; 584 585 static PyObject *FInfo_get_Type(FInfoObject *self, void *closure) 586 { 587 return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdType); 588 } 589 590 static int FInfo_set_Type(FInfoObject *self, PyObject *v, void *closure) 591 { 592 return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdType)-1; 593 return 0; 594 } 595 596 static PyObject *FInfo_get_Creator(FInfoObject *self, void *closure) 597 { 598 return Py_BuildValue("O&", PyMac_BuildOSType, self->ob_itself.fdCreator); 599 } 600 601 static int FInfo_set_Creator(FInfoObject *self, PyObject *v, void *closure) 602 { 603 return PyArg_Parse(v, "O&", PyMac_GetOSType, &self->ob_itself.fdCreator)-1; 604 return 0; 605 } 606 607 static PyObject *FInfo_get_Flags(FInfoObject *self, void *closure) 608 { 609 return Py_BuildValue("H", self->ob_itself.fdFlags); 610 } 611 612 static int FInfo_set_Flags(FInfoObject *self, PyObject *v, void *closure) 613 { 614 return PyArg_Parse(v, "H", &self->ob_itself.fdFlags)-1; 615 return 0; 616 } 617 618 static PyObject *FInfo_get_Location(FInfoObject *self, void *closure) 619 { 620 return Py_BuildValue("O&", PyMac_BuildPoint, self->ob_itself.fdLocation); 621 } 622 623 static int FInfo_set_Location(FInfoObject *self, PyObject *v, void *closure) 624 { 625 return PyArg_Parse(v, "O&", PyMac_GetPoint, &self->ob_itself.fdLocation)-1; 626 return 0; 627 } 628 629 static PyObject *FInfo_get_Fldr(FInfoObject *self, void *closure) 630 { 631 return Py_BuildValue("h", self->ob_itself.fdFldr); 632 } 633 634 static int FInfo_set_Fldr(FInfoObject *self, PyObject *v, void *closure) 635 { 636 return PyArg_Parse(v, "h", &self->ob_itself.fdFldr)-1; 637 return 0; 638 } 639 640 static PyGetSetDef FInfo_getsetlist[] = { 641 {"Type", (getter)FInfo_get_Type, (setter)FInfo_set_Type, "4-char file type"}, 642 {"Creator", (getter)FInfo_get_Creator, (setter)FInfo_set_Creator, "4-char file creator"}, 643 {"Flags", (getter)FInfo_get_Flags, (setter)FInfo_set_Flags, "Finder flag bits"}, 644 {"Location", (getter)FInfo_get_Location, (setter)FInfo_set_Location, "(x, y) location of the file's icon in its parent finder window"}, 645 {"Fldr", (getter)FInfo_get_Fldr, (setter)FInfo_set_Fldr, "Original folder, for 'put away'"}, 646 {NULL, NULL, NULL, NULL}, 647 }; 648 649 650 #define FInfo_compare NULL 651 652 #define FInfo_repr NULL 653 654 #define FInfo_hash NULL 655 static int FInfo_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) 656 { 657 FInfo *itself = NULL; 658 static char *kw[] = {"itself", 0}; 659 660 if (PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&", kw, FInfo_Convert, &itself)) 661 { 662 if (itself) memcpy(&((FInfoObject *)_self)->ob_itself, itself, sizeof(FInfo)); 663 return 0; 664 } 665 return -1; 666 } 667 668 #define FInfo_tp_alloc PyType_GenericAlloc 669 670 static PyObject *FInfo_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 671 { 672 PyObject *self; 673 674 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; 675 memset(&((FInfoObject *)self)->ob_itself, 0, sizeof(FInfo)); 676 return self; 677 } 678 679 #define FInfo_tp_free PyObject_Del 680 681 682 static PyTypeObject FInfo_Type = { 683 PyObject_HEAD_INIT(NULL) 684 0, /*ob_size*/ 685 "Carbon.File.FInfo", /*tp_name*/ 686 sizeof(FInfoObject), /*tp_basicsize*/ 687 0, /*tp_itemsize*/ 688 /* methods */ 689 (destructor) FInfo_dealloc, /*tp_dealloc*/ 690 0, /*tp_print*/ 691 (getattrfunc)0, /*tp_getattr*/ 692 (setattrfunc)0, /*tp_setattr*/ 693 (cmpfunc) FInfo_compare, /*tp_compare*/ 694 (reprfunc) FInfo_repr, /*tp_repr*/ 695 (PyNumberMethods *)0, /* tp_as_number */ 696 (PySequenceMethods *)0, /* tp_as_sequence */ 697 (PyMappingMethods *)0, /* tp_as_mapping */ 698 (hashfunc) FInfo_hash, /*tp_hash*/ 699 0, /*tp_call*/ 700 0, /*tp_str*/ 701 PyObject_GenericGetAttr, /*tp_getattro*/ 702 PyObject_GenericSetAttr, /*tp_setattro */ 703 0, /*tp_as_buffer*/ 704 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 705 0, /*tp_doc*/ 706 0, /*tp_traverse*/ 707 0, /*tp_clear*/ 708 0, /*tp_richcompare*/ 709 0, /*tp_weaklistoffset*/ 710 0, /*tp_iter*/ 711 0, /*tp_iternext*/ 712 FInfo_methods, /* tp_methods */ 713 0, /*tp_members*/ 714 FInfo_getsetlist, /*tp_getset*/ 715 0, /*tp_base*/ 716 0, /*tp_dict*/ 717 0, /*tp_descr_get*/ 718 0, /*tp_descr_set*/ 719 0, /*tp_dictoffset*/ 720 FInfo_tp_init, /* tp_init */ 721 FInfo_tp_alloc, /* tp_alloc */ 722 FInfo_tp_new, /* tp_new */ 723 FInfo_tp_free, /* tp_free */ 724 }; 725 726 #endif /* !__LP64__ */ 727 /* --------------------- End object type FInfo ---------------------- */ 728 729 730 /* ----------------------- Object type Alias ------------------------ */ 731 732 static PyTypeObject Alias_Type; 733 734 #define Alias_Check(x) ((x)->ob_type == &Alias_Type || PyObject_TypeCheck((x), &Alias_Type)) 735 736 typedef struct AliasObject { 737 PyObject_HEAD 738 AliasHandle ob_itself; 739 void (*ob_freeit)(AliasHandle ptr); 740 } AliasObject; 741 742 static PyObject *Alias_New(AliasHandle itself) 743 { 744 AliasObject *it; 745 if (itself == NULL) return PyMac_Error(resNotFound); 746 it = PyObject_NEW(AliasObject, &Alias_Type); 747 if (it == NULL) return NULL; 748 it->ob_itself = itself; 749 it->ob_freeit = NULL; 750 return (PyObject *)it; 751 } 752 753 static int Alias_Convert(PyObject *v, AliasHandle *p_itself) 754 { 755 if (!Alias_Check(v)) 756 { 757 PyErr_SetString(PyExc_TypeError, "Alias required"); 758 return 0; 759 } 760 *p_itself = ((AliasObject *)v)->ob_itself; 761 return 1; 762 } 763 764 static void Alias_dealloc(AliasObject *self) 765 { 766 if (self->ob_freeit && self->ob_itself) 767 { 768 self->ob_freeit(self->ob_itself); 769 } 770 self->ob_itself = NULL; 771 self->ob_type->tp_free((PyObject *)self); 772 } 773 774 #ifndef __LP64__ 775 static PyObject *Alias_ResolveAlias(AliasObject *_self, PyObject *_args) 776 { 777 PyObject *_res = NULL; 778 OSErr _err; 779 FSSpec fromFile__buf__; 780 FSSpec *fromFile = &fromFile__buf__; 781 FSSpec target; 782 Boolean wasChanged; 783 if (!PyArg_ParseTuple(_args, "O&", 784 myPyMac_GetOptFSSpecPtr, &fromFile)) 785 return NULL; 786 _err = ResolveAlias(fromFile, 787 _self->ob_itself, 788 &target, 789 &wasChanged); 790 if (_err != noErr) return PyMac_Error(_err); 791 _res = Py_BuildValue("O&b", 792 FSSpec_New, &target, 793 wasChanged); 794 return _res; 795 } 796 797 static PyObject *Alias_GetAliasInfo(AliasObject *_self, PyObject *_args) 798 { 799 PyObject *_res = NULL; 800 OSErr _err; 801 AliasInfoType index; 802 Str63 theString; 803 if (!PyArg_ParseTuple(_args, "h", 804 &index)) 805 return NULL; 806 _err = GetAliasInfo(_self->ob_itself, 807 index, 808 theString); 809 if (_err != noErr) return PyMac_Error(_err); 810 _res = Py_BuildValue("O&", 811 PyMac_BuildStr255, theString); 812 return _res; 813 } 814 815 static PyObject *Alias_ResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args) 816 { 817 PyObject *_res = NULL; 818 OSErr _err; 819 FSSpec fromFile__buf__; 820 FSSpec *fromFile = &fromFile__buf__; 821 FSSpec target; 822 Boolean wasChanged; 823 unsigned long mountFlags; 824 if (!PyArg_ParseTuple(_args, "O&l", 825 myPyMac_GetOptFSSpecPtr, &fromFile, 826 &mountFlags)) 827 return NULL; 828 _err = ResolveAliasWithMountFlags(fromFile, 829 _self->ob_itself, 830 &target, 831 &wasChanged, 832 mountFlags); 833 if (_err != noErr) return PyMac_Error(_err); 834 _res = Py_BuildValue("O&b", 835 FSSpec_New, &target, 836 wasChanged); 837 return _res; 838 } 839 840 static PyObject *Alias_FollowFinderAlias(AliasObject *_self, PyObject *_args) 841 { 842 PyObject *_res = NULL; 843 OSErr _err; 844 FSSpec fromFile__buf__; 845 FSSpec *fromFile = &fromFile__buf__; 846 Boolean logon; 847 FSSpec target; 848 Boolean wasChanged; 849 if (!PyArg_ParseTuple(_args, "O&b", 850 myPyMac_GetOptFSSpecPtr, &fromFile, 851 &logon)) 852 return NULL; 853 _err = FollowFinderAlias(fromFile, 854 _self->ob_itself, 855 logon, 856 &target, 857 &wasChanged); 858 if (_err != noErr) return PyMac_Error(_err); 859 _res = Py_BuildValue("O&b", 860 FSSpec_New, &target, 861 wasChanged); 862 return _res; 863 } 864 #endif /* !__LP64__ */ 865 866 static PyObject *Alias_FSResolveAliasWithMountFlags(AliasObject *_self, PyObject *_args) 867 { 868 PyObject *_res = NULL; 869 OSErr _err; 870 FSRef fromFile__buf__; 871 FSRef *fromFile = &fromFile__buf__; 872 FSRef target; 873 Boolean wasChanged; 874 unsigned long mountFlags; 875 if (!PyArg_ParseTuple(_args, "O&l", 876 myPyMac_GetOptFSRefPtr, &fromFile, 877 &mountFlags)) 878 return NULL; 879 _err = FSResolveAliasWithMountFlags(fromFile, 880 _self->ob_itself, 881 &target, 882 &wasChanged, 883 mountFlags); 884 if (_err != noErr) return PyMac_Error(_err); 885 _res = Py_BuildValue("O&b", 886 FSRef_New, &target, 887 wasChanged); 888 return _res; 889 } 890 891 static PyObject *Alias_FSResolveAlias(AliasObject *_self, PyObject *_args) 892 { 893 PyObject *_res = NULL; 894 OSErr _err; 895 FSRef fromFile__buf__; 896 FSRef *fromFile = &fromFile__buf__; 897 FSRef target; 898 Boolean wasChanged; 899 if (!PyArg_ParseTuple(_args, "O&", 900 myPyMac_GetOptFSRefPtr, &fromFile)) 901 return NULL; 902 _err = FSResolveAlias(fromFile, 903 _self->ob_itself, 904 &target, 905 &wasChanged); 906 if (_err != noErr) return PyMac_Error(_err); 907 _res = Py_BuildValue("O&b", 908 FSRef_New, &target, 909 wasChanged); 910 return _res; 911 } 912 913 static PyObject *Alias_FSFollowFinderAlias(AliasObject *_self, PyObject *_args) 914 { 915 PyObject *_res = NULL; 916 OSErr _err; 917 FSRef fromFile; 918 Boolean logon; 919 FSRef target; 920 Boolean wasChanged; 921 if (!PyArg_ParseTuple(_args, "b", 922 &logon)) 923 return NULL; 924 _err = FSFollowFinderAlias(&fromFile, 925 _self->ob_itself, 926 logon, 927 &target, 928 &wasChanged); 929 if (_err != noErr) return PyMac_Error(_err); 930 _res = Py_BuildValue("O&O&b", 931 FSRef_New, &fromFile, 932 FSRef_New, &target, 933 wasChanged); 934 return _res; 935 } 936 937 static PyMethodDef Alias_methods[] = { 938 #ifndef __LP64__ 939 {"ResolveAlias", (PyCFunction)Alias_ResolveAlias, 1, 940 PyDoc_STR("(FSSpec fromFile) -> (FSSpec target, Boolean wasChanged)")}, 941 {"GetAliasInfo", (PyCFunction)Alias_GetAliasInfo, 1, 942 PyDoc_STR("(AliasInfoType index) -> (Str63 theString)")}, 943 {"ResolveAliasWithMountFlags", (PyCFunction)Alias_ResolveAliasWithMountFlags, 1, 944 PyDoc_STR("(FSSpec fromFile, unsigned long mountFlags) -> (FSSpec target, Boolean wasChanged)")}, 945 {"FollowFinderAlias", (PyCFunction)Alias_FollowFinderAlias, 1, 946 PyDoc_STR("(FSSpec fromFile, Boolean logon) -> (FSSpec target, Boolean wasChanged)")}, 947 #endif /* !__LP64__ */ 948 {"FSResolveAliasWithMountFlags", (PyCFunction)Alias_FSResolveAliasWithMountFlags, 1, 949 PyDoc_STR("(FSRef fromFile, unsigned long mountFlags) -> (FSRef target, Boolean wasChanged)")}, 950 {"FSResolveAlias", (PyCFunction)Alias_FSResolveAlias, 1, 951 PyDoc_STR("(FSRef fromFile) -> (FSRef target, Boolean wasChanged)")}, 952 {"FSFollowFinderAlias", (PyCFunction)Alias_FSFollowFinderAlias, 1, 953 PyDoc_STR("(Boolean logon) -> (FSRef fromFile, FSRef target, Boolean wasChanged)")}, 954 {NULL, NULL, 0} 955 }; 956 957 static PyObject *Alias_get_data(AliasObject *self, void *closure) 958 { 959 int size; 960 PyObject *rv; 961 962 size = GetHandleSize((Handle)self->ob_itself); 963 HLock((Handle)self->ob_itself); 964 rv = PyString_FromStringAndSize(*(Handle)self->ob_itself, size); 965 HUnlock((Handle)self->ob_itself); 966 return rv; 967 968 } 969 970 #define Alias_set_data NULL 971 972 static PyGetSetDef Alias_getsetlist[] = { 973 {"data", (getter)Alias_get_data, (setter)Alias_set_data, "Raw data of the alias object"}, 974 {NULL, NULL, NULL, NULL}, 975 }; 976 977 978 #define Alias_compare NULL 979 980 #define Alias_repr NULL 981 982 #define Alias_hash NULL 983 static int Alias_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) 984 { 985 AliasHandle itself = NULL; 986 char *rawdata = NULL; 987 int rawdatalen = 0; 988 Handle h; 989 static char *kw[] = {"itself", "rawdata", 0}; 990 991 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|O&s#", kw, Alias_Convert, &itself, &rawdata, &rawdatalen)) 992 return -1; 993 if (itself && rawdata) 994 { 995 PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified"); 996 return -1; 997 } 998 if (!itself && !rawdata) 999 { 1000 PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified"); 1001 return -1; 1002 } 1003 if (rawdata) 1004 { 1005 if ((h = NewHandle(rawdatalen)) == NULL) 1006 { 1007 PyErr_NoMemory(); 1008 return -1; 1009 } 1010 HLock(h); 1011 memcpy((char *)*h, rawdata, rawdatalen); 1012 HUnlock(h); 1013 ((AliasObject *)_self)->ob_itself = (AliasHandle)h; 1014 return 0; 1015 } 1016 ((AliasObject *)_self)->ob_itself = itself; 1017 return 0; 1018 } 1019 1020 #define Alias_tp_alloc PyType_GenericAlloc 1021 1022 static PyObject *Alias_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 1023 { 1024 PyObject *self; 1025 1026 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; 1027 ((AliasObject *)self)->ob_itself = NULL; 1028 return self; 1029 } 1030 1031 #define Alias_tp_free PyObject_Del 1032 1033 1034 static PyTypeObject Alias_Type = { 1035 PyObject_HEAD_INIT(NULL) 1036 0, /*ob_size*/ 1037 "Carbon.File.Alias", /*tp_name*/ 1038 sizeof(AliasObject), /*tp_basicsize*/ 1039 0, /*tp_itemsize*/ 1040 /* methods */ 1041 (destructor) Alias_dealloc, /*tp_dealloc*/ 1042 0, /*tp_print*/ 1043 (getattrfunc)0, /*tp_getattr*/ 1044 (setattrfunc)0, /*tp_setattr*/ 1045 (cmpfunc) Alias_compare, /*tp_compare*/ 1046 (reprfunc) Alias_repr, /*tp_repr*/ 1047 (PyNumberMethods *)0, /* tp_as_number */ 1048 (PySequenceMethods *)0, /* tp_as_sequence */ 1049 (PyMappingMethods *)0, /* tp_as_mapping */ 1050 (hashfunc) Alias_hash, /*tp_hash*/ 1051 0, /*tp_call*/ 1052 0, /*tp_str*/ 1053 PyObject_GenericGetAttr, /*tp_getattro*/ 1054 PyObject_GenericSetAttr, /*tp_setattro */ 1055 0, /*tp_as_buffer*/ 1056 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 1057 0, /*tp_doc*/ 1058 0, /*tp_traverse*/ 1059 0, /*tp_clear*/ 1060 0, /*tp_richcompare*/ 1061 0, /*tp_weaklistoffset*/ 1062 0, /*tp_iter*/ 1063 0, /*tp_iternext*/ 1064 Alias_methods, /* tp_methods */ 1065 0, /*tp_members*/ 1066 Alias_getsetlist, /*tp_getset*/ 1067 0, /*tp_base*/ 1068 0, /*tp_dict*/ 1069 0, /*tp_descr_get*/ 1070 0, /*tp_descr_set*/ 1071 0, /*tp_dictoffset*/ 1072 Alias_tp_init, /* tp_init */ 1073 Alias_tp_alloc, /* tp_alloc */ 1074 Alias_tp_new, /* tp_new */ 1075 Alias_tp_free, /* tp_free */ 1076 }; 1077 1078 /* --------------------- End object type Alias ---------------------- */ 1079 1080 1081 /* ----------------------- Object type FSSpec ----------------------- */ 1082 #ifndef __LP64__ 1083 1084 static PyTypeObject FSSpec_Type; 1085 1086 #define FSSpec_Check(x) ((x)->ob_type == &FSSpec_Type || PyObject_TypeCheck((x), &FSSpec_Type)) 1087 1088 typedef struct FSSpecObject { 1089 PyObject_HEAD 1090 FSSpec ob_itself; 1091 } FSSpecObject; 1092 1093 static PyObject *FSSpec_New(FSSpec *itself) 1094 { 1095 FSSpecObject *it; 1096 if (itself == NULL) return PyMac_Error(resNotFound); 1097 it = PyObject_NEW(FSSpecObject, &FSSpec_Type); 1098 if (it == NULL) return NULL; 1099 it->ob_itself = *itself; 1100 return (PyObject *)it; 1101 } 1102 1103 static void FSSpec_dealloc(FSSpecObject *self) 1104 { 1105 /* Cleanup of self->ob_itself goes here */ 1106 self->ob_type->tp_free((PyObject *)self); 1107 } 1108 1109 static PyObject *FSSpec_FSpOpenDF(FSSpecObject *_self, PyObject *_args) 1110 { 1111 PyObject *_res = NULL; 1112 OSErr _err; 1113 SInt8 permission; 1114 short refNum; 1115 if (!PyArg_ParseTuple(_args, "b", 1116 &permission)) 1117 return NULL; 1118 _err = FSpOpenDF(&_self->ob_itself, 1119 permission, 1120 &refNum); 1121 if (_err != noErr) return PyMac_Error(_err); 1122 _res = Py_BuildValue("h", 1123 refNum); 1124 return _res; 1125 } 1126 1127 static PyObject *FSSpec_FSpOpenRF(FSSpecObject *_self, PyObject *_args) 1128 { 1129 PyObject *_res = NULL; 1130 OSErr _err; 1131 SInt8 permission; 1132 short refNum; 1133 if (!PyArg_ParseTuple(_args, "b", 1134 &permission)) 1135 return NULL; 1136 _err = FSpOpenRF(&_self->ob_itself, 1137 permission, 1138 &refNum); 1139 if (_err != noErr) return PyMac_Error(_err); 1140 _res = Py_BuildValue("h", 1141 refNum); 1142 return _res; 1143 } 1144 1145 static PyObject *FSSpec_FSpCreate(FSSpecObject *_self, PyObject *_args) 1146 { 1147 PyObject *_res = NULL; 1148 OSErr _err; 1149 OSType creator; 1150 OSType fileType; 1151 ScriptCode scriptTag; 1152 if (!PyArg_ParseTuple(_args, "O&O&h", 1153 PyMac_GetOSType, &creator, 1154 PyMac_GetOSType, &fileType, 1155 &scriptTag)) 1156 return NULL; 1157 _err = FSpCreate(&_self->ob_itself, 1158 creator, 1159 fileType, 1160 scriptTag); 1161 if (_err != noErr) return PyMac_Error(_err); 1162 Py_INCREF(Py_None); 1163 _res = Py_None; 1164 return _res; 1165 } 1166 1167 static PyObject *FSSpec_FSpDirCreate(FSSpecObject *_self, PyObject *_args) 1168 { 1169 PyObject *_res = NULL; 1170 OSErr _err; 1171 ScriptCode scriptTag; 1172 long createdDirID; 1173 if (!PyArg_ParseTuple(_args, "h", 1174 &scriptTag)) 1175 return NULL; 1176 _err = FSpDirCreate(&_self->ob_itself, 1177 scriptTag, 1178 &createdDirID); 1179 if (_err != noErr) return PyMac_Error(_err); 1180 _res = Py_BuildValue("l", 1181 createdDirID); 1182 return _res; 1183 } 1184 1185 static PyObject *FSSpec_FSpDelete(FSSpecObject *_self, PyObject *_args) 1186 { 1187 PyObject *_res = NULL; 1188 OSErr _err; 1189 if (!PyArg_ParseTuple(_args, "")) 1190 return NULL; 1191 _err = FSpDelete(&_self->ob_itself); 1192 if (_err != noErr) return PyMac_Error(_err); 1193 Py_INCREF(Py_None); 1194 _res = Py_None; 1195 return _res; 1196 } 1197 1198 static PyObject *FSSpec_FSpGetFInfo(FSSpecObject *_self, PyObject *_args) 1199 { 1200 PyObject *_res = NULL; 1201 OSErr _err; 1202 FInfo fndrInfo; 1203 if (!PyArg_ParseTuple(_args, "")) 1204 return NULL; 1205 _err = FSpGetFInfo(&_self->ob_itself, 1206 &fndrInfo); 1207 if (_err != noErr) return PyMac_Error(_err); 1208 _res = Py_BuildValue("O&", 1209 FInfo_New, &fndrInfo); 1210 return _res; 1211 } 1212 1213 static PyObject *FSSpec_FSpSetFInfo(FSSpecObject *_self, PyObject *_args) 1214 { 1215 PyObject *_res = NULL; 1216 OSErr _err; 1217 FInfo fndrInfo; 1218 if (!PyArg_ParseTuple(_args, "O&", 1219 FInfo_Convert, &fndrInfo)) 1220 return NULL; 1221 _err = FSpSetFInfo(&_self->ob_itself, 1222 &fndrInfo); 1223 if (_err != noErr) return PyMac_Error(_err); 1224 Py_INCREF(Py_None); 1225 _res = Py_None; 1226 return _res; 1227 } 1228 1229 static PyObject *FSSpec_FSpSetFLock(FSSpecObject *_self, PyObject *_args) 1230 { 1231 PyObject *_res = NULL; 1232 OSErr _err; 1233 if (!PyArg_ParseTuple(_args, "")) 1234 return NULL; 1235 _err = FSpSetFLock(&_self->ob_itself); 1236 if (_err != noErr) return PyMac_Error(_err); 1237 Py_INCREF(Py_None); 1238 _res = Py_None; 1239 return _res; 1240 } 1241 1242 static PyObject *FSSpec_FSpRstFLock(FSSpecObject *_self, PyObject *_args) 1243 { 1244 PyObject *_res = NULL; 1245 OSErr _err; 1246 if (!PyArg_ParseTuple(_args, "")) 1247 return NULL; 1248 _err = FSpRstFLock(&_self->ob_itself); 1249 if (_err != noErr) return PyMac_Error(_err); 1250 Py_INCREF(Py_None); 1251 _res = Py_None; 1252 return _res; 1253 } 1254 1255 static PyObject *FSSpec_FSpRename(FSSpecObject *_self, PyObject *_args) 1256 { 1257 PyObject *_res = NULL; 1258 OSErr _err; 1259 Str255 newName; 1260 if (!PyArg_ParseTuple(_args, "O&", 1261 PyMac_GetStr255, newName)) 1262 return NULL; 1263 _err = FSpRename(&_self->ob_itself, 1264 newName); 1265 if (_err != noErr) return PyMac_Error(_err); 1266 Py_INCREF(Py_None); 1267 _res = Py_None; 1268 return _res; 1269 } 1270 1271 static PyObject *FSSpec_FSpCatMove(FSSpecObject *_self, PyObject *_args) 1272 { 1273 PyObject *_res = NULL; 1274 OSErr _err; 1275 FSSpec dest; 1276 if (!PyArg_ParseTuple(_args, "O&", 1277 FSSpec_Convert, &dest)) 1278 return NULL; 1279 _err = FSpCatMove(&_self->ob_itself, 1280 &dest); 1281 if (_err != noErr) return PyMac_Error(_err); 1282 Py_INCREF(Py_None); 1283 _res = Py_None; 1284 return _res; 1285 } 1286 1287 static PyObject *FSSpec_FSpExchangeFiles(FSSpecObject *_self, PyObject *_args) 1288 { 1289 PyObject *_res = NULL; 1290 OSErr _err; 1291 FSSpec dest; 1292 if (!PyArg_ParseTuple(_args, "O&", 1293 FSSpec_Convert, &dest)) 1294 return NULL; 1295 _err = FSpExchangeFiles(&_self->ob_itself, 1296 &dest); 1297 if (_err != noErr) return PyMac_Error(_err); 1298 Py_INCREF(Py_None); 1299 _res = Py_None; 1300 return _res; 1301 } 1302 1303 static PyObject *FSSpec_FSpMakeFSRef(FSSpecObject *_self, PyObject *_args) 1304 { 1305 PyObject *_res = NULL; 1306 OSErr _err; 1307 FSRef newRef; 1308 if (!PyArg_ParseTuple(_args, "")) 1309 return NULL; 1310 _err = FSpMakeFSRef(&_self->ob_itself, 1311 &newRef); 1312 if (_err != noErr) return PyMac_Error(_err); 1313 _res = Py_BuildValue("O&", 1314 FSRef_New, &newRef); 1315 return _res; 1316 } 1317 1318 static PyObject *FSSpec_NewAliasMinimal(FSSpecObject *_self, PyObject *_args) 1319 { 1320 PyObject *_res = NULL; 1321 OSErr _err; 1322 AliasHandle alias; 1323 if (!PyArg_ParseTuple(_args, "")) 1324 return NULL; 1325 _err = NewAliasMinimal(&_self->ob_itself, 1326 &alias); 1327 if (_err != noErr) return PyMac_Error(_err); 1328 _res = Py_BuildValue("O&", 1329 Alias_New, alias); 1330 return _res; 1331 } 1332 1333 static PyObject *FSSpec_IsAliasFile(FSSpecObject *_self, PyObject *_args) 1334 { 1335 PyObject *_res = NULL; 1336 OSErr _err; 1337 Boolean aliasFileFlag; 1338 Boolean folderFlag; 1339 if (!PyArg_ParseTuple(_args, "")) 1340 return NULL; 1341 _err = IsAliasFile(&_self->ob_itself, 1342 &aliasFileFlag, 1343 &folderFlag); 1344 if (_err != noErr) return PyMac_Error(_err); 1345 _res = Py_BuildValue("bb", 1346 aliasFileFlag, 1347 folderFlag); 1348 return _res; 1349 } 1350 1351 static PyObject *FSSpec_as_pathname(FSSpecObject *_self, PyObject *_args) 1352 { 1353 PyObject *_res = NULL; 1354 1355 char strbuf[1024]; 1356 OSErr err; 1357 1358 if (!PyArg_ParseTuple(_args, "")) 1359 return NULL; 1360 err = _PyMac_GetFullPathname(&_self->ob_itself, strbuf, sizeof(strbuf)); 1361 if ( err ) { 1362 PyMac_Error(err); 1363 return NULL; 1364 } 1365 _res = PyString_FromString(strbuf); 1366 return _res; 1367 1368 } 1369 1370 static PyObject *FSSpec_as_tuple(FSSpecObject *_self, PyObject *_args) 1371 { 1372 PyObject *_res = NULL; 1373 1374 if (!PyArg_ParseTuple(_args, "")) 1375 return NULL; 1376 _res = Py_BuildValue("(iis#)", _self->ob_itself.vRefNum, _self->ob_itself.parID, 1377 &_self->ob_itself.name[1], _self->ob_itself.name[0]); 1378 return _res; 1379 1380 } 1381 1382 static PyMethodDef FSSpec_methods[] = { 1383 {"FSpOpenDF", (PyCFunction)FSSpec_FSpOpenDF, 1, 1384 PyDoc_STR("(SInt8 permission) -> (short refNum)")}, 1385 {"FSpOpenRF", (PyCFunction)FSSpec_FSpOpenRF, 1, 1386 PyDoc_STR("(SInt8 permission) -> (short refNum)")}, 1387 {"FSpCreate", (PyCFunction)FSSpec_FSpCreate, 1, 1388 PyDoc_STR("(OSType creator, OSType fileType, ScriptCode scriptTag) -> None")}, 1389 {"FSpDirCreate", (PyCFunction)FSSpec_FSpDirCreate, 1, 1390 PyDoc_STR("(ScriptCode scriptTag) -> (long createdDirID)")}, 1391 {"FSpDelete", (PyCFunction)FSSpec_FSpDelete, 1, 1392 PyDoc_STR("() -> None")}, 1393 {"FSpGetFInfo", (PyCFunction)FSSpec_FSpGetFInfo, 1, 1394 PyDoc_STR("() -> (FInfo fndrInfo)")}, 1395 {"FSpSetFInfo", (PyCFunction)FSSpec_FSpSetFInfo, 1, 1396 PyDoc_STR("(FInfo fndrInfo) -> None")}, 1397 {"FSpSetFLock", (PyCFunction)FSSpec_FSpSetFLock, 1, 1398 PyDoc_STR("() -> None")}, 1399 {"FSpRstFLock", (PyCFunction)FSSpec_FSpRstFLock, 1, 1400 PyDoc_STR("() -> None")}, 1401 {"FSpRename", (PyCFunction)FSSpec_FSpRename, 1, 1402 PyDoc_STR("(Str255 newName) -> None")}, 1403 {"FSpCatMove", (PyCFunction)FSSpec_FSpCatMove, 1, 1404 PyDoc_STR("(FSSpec dest) -> None")}, 1405 {"FSpExchangeFiles", (PyCFunction)FSSpec_FSpExchangeFiles, 1, 1406 PyDoc_STR("(FSSpec dest) -> None")}, 1407 {"FSpMakeFSRef", (PyCFunction)FSSpec_FSpMakeFSRef, 1, 1408 PyDoc_STR("() -> (FSRef newRef)")}, 1409 {"NewAliasMinimal", (PyCFunction)FSSpec_NewAliasMinimal, 1, 1410 PyDoc_STR("() -> (AliasHandle alias)")}, 1411 {"IsAliasFile", (PyCFunction)FSSpec_IsAliasFile, 1, 1412 PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")}, 1413 {"as_pathname", (PyCFunction)FSSpec_as_pathname, 1, 1414 PyDoc_STR("() -> string")}, 1415 {"as_tuple", (PyCFunction)FSSpec_as_tuple, 1, 1416 PyDoc_STR("() -> (vRefNum, dirID, name)")}, 1417 {NULL, NULL, 0} 1418 }; 1419 1420 static PyObject *FSSpec_get_data(FSSpecObject *self, void *closure) 1421 { 1422 return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself)); 1423 } 1424 1425 #define FSSpec_set_data NULL 1426 1427 static PyGetSetDef FSSpec_getsetlist[] = { 1428 {"data", (getter)FSSpec_get_data, (setter)FSSpec_set_data, "Raw data of the FSSpec object"}, 1429 {NULL, NULL, NULL, NULL}, 1430 }; 1431 1432 1433 #define FSSpec_compare NULL 1434 1435 static PyObject * FSSpec_repr(FSSpecObject *self) 1436 { 1437 char buf[512]; 1438 PyOS_snprintf(buf, sizeof(buf), "%s((%d, %ld, '%.*s'))", 1439 self->ob_type->tp_name, 1440 self->ob_itself.vRefNum, 1441 self->ob_itself.parID, 1442 self->ob_itself.name[0], self->ob_itself.name+1); 1443 return PyString_FromString(buf); 1444 } 1445 1446 #define FSSpec_hash NULL 1447 static int FSSpec_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) 1448 { 1449 PyObject *v = NULL; 1450 char *rawdata = NULL; 1451 int rawdatalen = 0; 1452 static char *kw[] = {"itself", "rawdata", 0}; 1453 1454 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen)) 1455 return -1; 1456 if (v && rawdata) 1457 { 1458 PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified"); 1459 return -1; 1460 } 1461 if (!v && !rawdata) 1462 { 1463 PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified"); 1464 return -1; 1465 } 1466 if (rawdata) 1467 { 1468 if (rawdatalen != sizeof(FSSpec)) 1469 { 1470 PyErr_SetString(PyExc_TypeError, "FSSpec rawdata incorrect size"); 1471 return -1; 1472 } 1473 memcpy(&((FSSpecObject *)_self)->ob_itself, rawdata, rawdatalen); 1474 return 0; 1475 } 1476 if (PyMac_GetFSSpec(v, &((FSSpecObject *)_self)->ob_itself)) return 0; 1477 return -1; 1478 } 1479 1480 #define FSSpec_tp_alloc PyType_GenericAlloc 1481 1482 static PyObject *FSSpec_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 1483 { 1484 PyObject *self; 1485 1486 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; 1487 memset(&((FSSpecObject *)self)->ob_itself, 0, sizeof(FSSpec)); 1488 return self; 1489 } 1490 1491 #define FSSpec_tp_free PyObject_Del 1492 1493 1494 static PyTypeObject FSSpec_Type = { 1495 PyObject_HEAD_INIT(NULL) 1496 0, /*ob_size*/ 1497 "Carbon.File.FSSpec", /*tp_name*/ 1498 sizeof(FSSpecObject), /*tp_basicsize*/ 1499 0, /*tp_itemsize*/ 1500 /* methods */ 1501 (destructor) FSSpec_dealloc, /*tp_dealloc*/ 1502 0, /*tp_print*/ 1503 (getattrfunc)0, /*tp_getattr*/ 1504 (setattrfunc)0, /*tp_setattr*/ 1505 (cmpfunc) FSSpec_compare, /*tp_compare*/ 1506 (reprfunc) FSSpec_repr, /*tp_repr*/ 1507 (PyNumberMethods *)0, /* tp_as_number */ 1508 (PySequenceMethods *)0, /* tp_as_sequence */ 1509 (PyMappingMethods *)0, /* tp_as_mapping */ 1510 (hashfunc) FSSpec_hash, /*tp_hash*/ 1511 0, /*tp_call*/ 1512 0, /*tp_str*/ 1513 PyObject_GenericGetAttr, /*tp_getattro*/ 1514 PyObject_GenericSetAttr, /*tp_setattro */ 1515 0, /*tp_as_buffer*/ 1516 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 1517 0, /*tp_doc*/ 1518 0, /*tp_traverse*/ 1519 0, /*tp_clear*/ 1520 0, /*tp_richcompare*/ 1521 0, /*tp_weaklistoffset*/ 1522 0, /*tp_iter*/ 1523 0, /*tp_iternext*/ 1524 FSSpec_methods, /* tp_methods */ 1525 0, /*tp_members*/ 1526 FSSpec_getsetlist, /*tp_getset*/ 1527 0, /*tp_base*/ 1528 0, /*tp_dict*/ 1529 0, /*tp_descr_get*/ 1530 0, /*tp_descr_set*/ 1531 0, /*tp_dictoffset*/ 1532 FSSpec_tp_init, /* tp_init */ 1533 FSSpec_tp_alloc, /* tp_alloc */ 1534 FSSpec_tp_new, /* tp_new */ 1535 FSSpec_tp_free, /* tp_free */ 1536 }; 1537 1538 #endif /* !__LP64__ */ 1539 /* --------------------- End object type FSSpec --------------------- */ 1540 1541 1542 /* ----------------------- Object type FSRef ------------------------ */ 1543 1544 static PyTypeObject FSRef_Type; 1545 1546 #define FSRef_Check(x) ((x)->ob_type == &FSRef_Type || PyObject_TypeCheck((x), &FSRef_Type)) 1547 1548 typedef struct FSRefObject { 1549 PyObject_HEAD 1550 FSRef ob_itself; 1551 } FSRefObject; 1552 1553 static PyObject *FSRef_New(FSRef *itself) 1554 { 1555 FSRefObject *it; 1556 if (itself == NULL) return PyMac_Error(resNotFound); 1557 it = PyObject_NEW(FSRefObject, &FSRef_Type); 1558 if (it == NULL) return NULL; 1559 it->ob_itself = *itself; 1560 return (PyObject *)it; 1561 } 1562 1563 static void FSRef_dealloc(FSRefObject *self) 1564 { 1565 /* Cleanup of self->ob_itself goes here */ 1566 self->ob_type->tp_free((PyObject *)self); 1567 } 1568 1569 static PyObject *FSRef_FSMakeFSRefUnicode(FSRefObject *_self, PyObject *_args) 1570 { 1571 PyObject *_res = NULL; 1572 OSErr _err; 1573 UniChar *nameLength__in__; 1574 UniCharCount nameLength__len__; 1575 int nameLength__in_len__; 1576 TextEncoding textEncodingHint; 1577 FSRef newRef; 1578 if (!PyArg_ParseTuple(_args, "u#l", 1579 &nameLength__in__, &nameLength__in_len__, 1580 &textEncodingHint)) 1581 return NULL; 1582 nameLength__len__ = nameLength__in_len__; 1583 _err = FSMakeFSRefUnicode(&_self->ob_itself, 1584 nameLength__len__, nameLength__in__, 1585 textEncodingHint, 1586 &newRef); 1587 if (_err != noErr) return PyMac_Error(_err); 1588 _res = Py_BuildValue("O&", 1589 FSRef_New, &newRef); 1590 return _res; 1591 } 1592 1593 static PyObject *FSRef_FSCompareFSRefs(FSRefObject *_self, PyObject *_args) 1594 { 1595 PyObject *_res = NULL; 1596 OSErr _err; 1597 FSRef ref2; 1598 if (!PyArg_ParseTuple(_args, "O&", 1599 FSRef_Convert, &ref2)) 1600 return NULL; 1601 _err = FSCompareFSRefs(&_self->ob_itself, 1602 &ref2); 1603 if (_err != noErr) return PyMac_Error(_err); 1604 Py_INCREF(Py_None); 1605 _res = Py_None; 1606 return _res; 1607 } 1608 1609 static PyObject *FSRef_FSCreateFileUnicode(FSRefObject *_self, PyObject *_args) 1610 { 1611 PyObject *_res = NULL; 1612 OSErr _err; 1613 UniChar *nameLength__in__; 1614 UniCharCount nameLength__len__; 1615 int nameLength__in_len__; 1616 FSCatalogInfoBitmap whichInfo; 1617 FSCatalogInfo catalogInfo; 1618 FSRef newRef; 1619 #ifndef __LP64__ 1620 FSSpec newSpec; 1621 #endif 1622 if (!PyArg_ParseTuple(_args, "u#lO&", 1623 &nameLength__in__, &nameLength__in_len__, 1624 &whichInfo, 1625 FSCatalogInfo_Convert, &catalogInfo)) 1626 return NULL; 1627 nameLength__len__ = nameLength__in_len__; 1628 _err = FSCreateFileUnicode(&_self->ob_itself, 1629 nameLength__len__, nameLength__in__, 1630 whichInfo, 1631 &catalogInfo, 1632 &newRef, 1633 #ifndef __LP64__ 1634 &newSpec 1635 #else /* __LP64__ */ 1636 NULL 1637 #endif /* __LP64__*/ 1638 ); 1639 if (_err != noErr) return PyMac_Error(_err); 1640 1641 #ifndef __LP64__ 1642 _res = Py_BuildValue("O&O&", 1643 FSRef_New, &newRef, 1644 FSSpec_New, &newSpec); 1645 #else /* __LP64__ */ 1646 _res = Py_BuildValue("O&O", FSRef_New, &newRef, Py_None); 1647 #endif /* __LP64__ */ 1648 1649 return _res; 1650 } 1651 1652 static PyObject *FSRef_FSCreateDirectoryUnicode(FSRefObject *_self, PyObject *_args) 1653 { 1654 PyObject *_res = NULL; 1655 OSErr _err; 1656 UniChar *nameLength__in__; 1657 UniCharCount nameLength__len__; 1658 int nameLength__in_len__; 1659 FSCatalogInfoBitmap whichInfo; 1660 FSCatalogInfo catalogInfo; 1661 FSRef newRef; 1662 #ifndef __LP64__ 1663 FSSpec newSpec; 1664 #endif /* !__LP64__ */ 1665 UInt32 newDirID; 1666 if (!PyArg_ParseTuple(_args, "u#lO&", 1667 &nameLength__in__, &nameLength__in_len__, 1668 &whichInfo, 1669 FSCatalogInfo_Convert, &catalogInfo)) 1670 return NULL; 1671 nameLength__len__ = nameLength__in_len__; 1672 _err = FSCreateDirectoryUnicode(&_self->ob_itself, 1673 nameLength__len__, nameLength__in__, 1674 whichInfo, 1675 &catalogInfo, 1676 &newRef, 1677 #ifndef __LP64__ 1678 &newSpec, 1679 #else /* !__LP64__ */ 1680 NULL, 1681 #endif /* !__LP64__ */ 1682 &newDirID); 1683 if (_err != noErr) return PyMac_Error(_err); 1684 1685 #ifndef __LP64__ 1686 _res = Py_BuildValue("O&O&l", 1687 FSRef_New, &newRef, 1688 FSSpec_New, &newSpec, 1689 newDirID); 1690 #else /* __LP64__ */ 1691 _res = Py_BuildValue("O&Ol", 1692 FSRef_New, &newRef, 1693 Py_None, 1694 newDirID); 1695 #endif /* __LP64__ */ 1696 return _res; 1697 } 1698 1699 static PyObject *FSRef_FSDeleteObject(FSRefObject *_self, PyObject *_args) 1700 { 1701 PyObject *_res = NULL; 1702 OSErr _err; 1703 if (!PyArg_ParseTuple(_args, "")) 1704 return NULL; 1705 _err = FSDeleteObject(&_self->ob_itself); 1706 if (_err != noErr) return PyMac_Error(_err); 1707 Py_INCREF(Py_None); 1708 _res = Py_None; 1709 return _res; 1710 } 1711 1712 static PyObject *FSRef_FSMoveObject(FSRefObject *_self, PyObject *_args) 1713 { 1714 PyObject *_res = NULL; 1715 OSErr _err; 1716 FSRef destDirectory; 1717 FSRef newRef; 1718 if (!PyArg_ParseTuple(_args, "O&", 1719 FSRef_Convert, &destDirectory)) 1720 return NULL; 1721 _err = FSMoveObject(&_self->ob_itself, 1722 &destDirectory, 1723 &newRef); 1724 if (_err != noErr) return PyMac_Error(_err); 1725 _res = Py_BuildValue("O&", 1726 FSRef_New, &newRef); 1727 return _res; 1728 } 1729 1730 static PyObject *FSRef_FSExchangeObjects(FSRefObject *_self, PyObject *_args) 1731 { 1732 PyObject *_res = NULL; 1733 OSErr _err; 1734 FSRef destRef; 1735 if (!PyArg_ParseTuple(_args, "O&", 1736 FSRef_Convert, &destRef)) 1737 return NULL; 1738 _err = FSExchangeObjects(&_self->ob_itself, 1739 &destRef); 1740 if (_err != noErr) return PyMac_Error(_err); 1741 Py_INCREF(Py_None); 1742 _res = Py_None; 1743 return _res; 1744 } 1745 1746 static PyObject *FSRef_FSRenameUnicode(FSRefObject *_self, PyObject *_args) 1747 { 1748 PyObject *_res = NULL; 1749 OSErr _err; 1750 UniChar *nameLength__in__; 1751 UniCharCount nameLength__len__; 1752 int nameLength__in_len__; 1753 TextEncoding textEncodingHint; 1754 FSRef newRef; 1755 if (!PyArg_ParseTuple(_args, "u#l", 1756 &nameLength__in__, &nameLength__in_len__, 1757 &textEncodingHint)) 1758 return NULL; 1759 nameLength__len__ = nameLength__in_len__; 1760 _err = FSRenameUnicode(&_self->ob_itself, 1761 nameLength__len__, nameLength__in__, 1762 textEncodingHint, 1763 &newRef); 1764 if (_err != noErr) return PyMac_Error(_err); 1765 _res = Py_BuildValue("O&", 1766 FSRef_New, &newRef); 1767 return _res; 1768 } 1769 1770 static PyObject *FSRef_FSGetCatalogInfo(FSRefObject *_self, PyObject *_args) 1771 { 1772 PyObject *_res = NULL; 1773 OSErr _err; 1774 FSCatalogInfoBitmap whichInfo; 1775 FSCatalogInfo catalogInfo; 1776 HFSUniStr255 outName; 1777 #ifndef __LP64__ 1778 FSSpec fsSpec; 1779 #endif /* !__LP64__ */ 1780 FSRef parentRef; 1781 if (!PyArg_ParseTuple(_args, "l", 1782 &whichInfo)) 1783 return NULL; 1784 _err = FSGetCatalogInfo(&_self->ob_itself, 1785 whichInfo, 1786 &catalogInfo, 1787 &outName, 1788 #ifndef __LP64__ 1789 &fsSpec, 1790 #else /* __LP64__ */ 1791 NULL, 1792 #endif /* __LP64__ */ 1793 &parentRef); 1794 if (_err != noErr) return PyMac_Error(_err); 1795 1796 #ifndef __LP64__ 1797 _res = Py_BuildValue("O&O&O&O&", 1798 FSCatalogInfo_New, &catalogInfo, 1799 PyMac_BuildHFSUniStr255, &outName, 1800 FSSpec_New, &fsSpec, 1801 FSRef_New, &parentRef); 1802 #else /* __LP64__ */ 1803 _res = Py_BuildValue("O&O&OO&", 1804 FSCatalogInfo_New, &catalogInfo, 1805 PyMac_BuildHFSUniStr255, &outName, 1806 Py_None, 1807 FSRef_New, &parentRef); 1808 #endif /* __LP64__ */ 1809 return _res; 1810 } 1811 1812 static PyObject *FSRef_FSSetCatalogInfo(FSRefObject *_self, PyObject *_args) 1813 { 1814 PyObject *_res = NULL; 1815 OSErr _err; 1816 FSCatalogInfoBitmap whichInfo; 1817 FSCatalogInfo catalogInfo; 1818 if (!PyArg_ParseTuple(_args, "lO&", 1819 &whichInfo, 1820 FSCatalogInfo_Convert, &catalogInfo)) 1821 return NULL; 1822 _err = FSSetCatalogInfo(&_self->ob_itself, 1823 whichInfo, 1824 &catalogInfo); 1825 if (_err != noErr) return PyMac_Error(_err); 1826 Py_INCREF(Py_None); 1827 _res = Py_None; 1828 return _res; 1829 } 1830 1831 static PyObject *FSRef_FSCreateFork(FSRefObject *_self, PyObject *_args) 1832 { 1833 PyObject *_res = NULL; 1834 OSErr _err; 1835 UniChar *forkNameLength__in__; 1836 UniCharCount forkNameLength__len__; 1837 int forkNameLength__in_len__; 1838 if (!PyArg_ParseTuple(_args, "u#", 1839 &forkNameLength__in__, &forkNameLength__in_len__)) 1840 return NULL; 1841 forkNameLength__len__ = forkNameLength__in_len__; 1842 _err = FSCreateFork(&_self->ob_itself, 1843 forkNameLength__len__, forkNameLength__in__); 1844 if (_err != noErr) return PyMac_Error(_err); 1845 Py_INCREF(Py_None); 1846 _res = Py_None; 1847 return _res; 1848 } 1849 1850 static PyObject *FSRef_FSDeleteFork(FSRefObject *_self, PyObject *_args) 1851 { 1852 PyObject *_res = NULL; 1853 OSErr _err; 1854 UniChar *forkNameLength__in__; 1855 UniCharCount forkNameLength__len__; 1856 int forkNameLength__in_len__; 1857 if (!PyArg_ParseTuple(_args, "u#", 1858 &forkNameLength__in__, &forkNameLength__in_len__)) 1859 return NULL; 1860 forkNameLength__len__ = forkNameLength__in_len__; 1861 _err = FSDeleteFork(&_self->ob_itself, 1862 forkNameLength__len__, forkNameLength__in__); 1863 if (_err != noErr) return PyMac_Error(_err); 1864 Py_INCREF(Py_None); 1865 _res = Py_None; 1866 return _res; 1867 } 1868 1869 static PyObject *FSRef_FSOpenFork(FSRefObject *_self, PyObject *_args) 1870 { 1871 PyObject *_res = NULL; 1872 OSErr _err; 1873 UniChar *forkNameLength__in__; 1874 UniCharCount forkNameLength__len__; 1875 int forkNameLength__in_len__; 1876 SInt8 permissions; 1877 FSIORefNum forkRefNum; 1878 if (!PyArg_ParseTuple(_args, "u#b", 1879 &forkNameLength__in__, &forkNameLength__in_len__, 1880 &permissions)) 1881 return NULL; 1882 forkNameLength__len__ = forkNameLength__in_len__; 1883 _err = FSOpenFork(&_self->ob_itself, 1884 forkNameLength__len__, forkNameLength__in__, 1885 permissions, 1886 &forkRefNum); 1887 if (_err != noErr) return PyMac_Error(_err); 1888 _res = Py_BuildValue("h", 1889 forkRefNum); 1890 return _res; 1891 } 1892 1893 static PyObject *FSRef_FNNotify(FSRefObject *_self, PyObject *_args) 1894 { 1895 PyObject *_res = NULL; 1896 OSStatus _err; 1897 FNMessage message; 1898 OptionBits flags; 1899 if (!PyArg_ParseTuple(_args, "ll", 1900 &message, 1901 &flags)) 1902 return NULL; 1903 _err = FNNotify(&_self->ob_itself, 1904 message, 1905 flags); 1906 if (_err != noErr) return PyMac_Error(_err); 1907 Py_INCREF(Py_None); 1908 _res = Py_None; 1909 return _res; 1910 } 1911 1912 static PyObject *FSRef_FSNewAliasMinimal(FSRefObject *_self, PyObject *_args) 1913 { 1914 PyObject *_res = NULL; 1915 OSErr _err; 1916 AliasHandle inAlias; 1917 if (!PyArg_ParseTuple(_args, "")) 1918 return NULL; 1919 _err = FSNewAliasMinimal(&_self->ob_itself, 1920 &inAlias); 1921 if (_err != noErr) return PyMac_Error(_err); 1922 _res = Py_BuildValue("O&", 1923 Alias_New, inAlias); 1924 return _res; 1925 } 1926 1927 static PyObject *FSRef_FSIsAliasFile(FSRefObject *_self, PyObject *_args) 1928 { 1929 PyObject *_res = NULL; 1930 OSErr _err; 1931 Boolean aliasFileFlag; 1932 Boolean folderFlag; 1933 if (!PyArg_ParseTuple(_args, "")) 1934 return NULL; 1935 _err = FSIsAliasFile(&_self->ob_itself, 1936 &aliasFileFlag, 1937 &folderFlag); 1938 if (_err != noErr) return PyMac_Error(_err); 1939 _res = Py_BuildValue("bb", 1940 aliasFileFlag, 1941 folderFlag); 1942 return _res; 1943 } 1944 1945 static PyObject *FSRef_FSRefMakePath(FSRefObject *_self, PyObject *_args) 1946 { 1947 PyObject *_res = NULL; 1948 1949 OSStatus _err; 1950 #define MAXPATHNAME 1024 1951 UInt8 path[MAXPATHNAME]; 1952 UInt32 maxPathSize = MAXPATHNAME; 1953 1954 if (!PyArg_ParseTuple(_args, "")) 1955 return NULL; 1956 _err = FSRefMakePath(&_self->ob_itself, 1957 path, 1958 maxPathSize); 1959 if (_err != noErr) return PyMac_Error(_err); 1960 _res = Py_BuildValue("s", path); 1961 return _res; 1962 1963 } 1964 1965 static PyObject *FSRef_as_pathname(FSRefObject *_self, PyObject *_args) 1966 { 1967 PyObject *_res = NULL; 1968 1969 if (!PyArg_ParseTuple(_args, "")) 1970 return NULL; 1971 _res = FSRef_FSRefMakePath(_self, _args); 1972 return _res; 1973 1974 } 1975 1976 static PyMethodDef FSRef_methods[] = { 1977 {"FSMakeFSRefUnicode", (PyCFunction)FSRef_FSMakeFSRefUnicode, 1, 1978 PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")}, 1979 {"FSCompareFSRefs", (PyCFunction)FSRef_FSCompareFSRefs, 1, 1980 PyDoc_STR("(FSRef ref2) -> None")}, 1981 {"FSCreateFileUnicode", (PyCFunction)FSRef_FSCreateFileUnicode, 1, 1982 PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec)")}, 1983 {"FSCreateDirectoryUnicode", (PyCFunction)FSRef_FSCreateDirectoryUnicode, 1, 1984 PyDoc_STR("(Buffer nameLength, FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> (FSRef newRef, FSSpec newSpec, UInt32 newDirID)")}, 1985 {"FSDeleteObject", (PyCFunction)FSRef_FSDeleteObject, 1, 1986 PyDoc_STR("() -> None")}, 1987 {"FSMoveObject", (PyCFunction)FSRef_FSMoveObject, 1, 1988 PyDoc_STR("(FSRef destDirectory) -> (FSRef newRef)")}, 1989 {"FSExchangeObjects", (PyCFunction)FSRef_FSExchangeObjects, 1, 1990 PyDoc_STR("(FSRef destRef) -> None")}, 1991 {"FSRenameUnicode", (PyCFunction)FSRef_FSRenameUnicode, 1, 1992 PyDoc_STR("(Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")}, 1993 {"FSGetCatalogInfo", (PyCFunction)FSRef_FSGetCatalogInfo, 1, 1994 PyDoc_STR("(FSCatalogInfoBitmap whichInfo) -> (FSCatalogInfo catalogInfo, HFSUniStr255 outName, FSSpec fsSpec, FSRef parentRef)")}, 1995 {"FSSetCatalogInfo", (PyCFunction)FSRef_FSSetCatalogInfo, 1, 1996 PyDoc_STR("(FSCatalogInfoBitmap whichInfo, FSCatalogInfo catalogInfo) -> None")}, 1997 {"FSCreateFork", (PyCFunction)FSRef_FSCreateFork, 1, 1998 PyDoc_STR("(Buffer forkNameLength) -> None")}, 1999 {"FSDeleteFork", (PyCFunction)FSRef_FSDeleteFork, 1, 2000 PyDoc_STR("(Buffer forkNameLength) -> None")}, 2001 {"FSOpenFork", (PyCFunction)FSRef_FSOpenFork, 1, 2002 PyDoc_STR("(Buffer forkNameLength, SInt8 permissions) -> (SInt16 forkRefNum)")}, 2003 {"FNNotify", (PyCFunction)FSRef_FNNotify, 1, 2004 PyDoc_STR("(FNMessage message, OptionBits flags) -> None")}, 2005 {"FSNewAliasMinimal", (PyCFunction)FSRef_FSNewAliasMinimal, 1, 2006 PyDoc_STR("() -> (AliasHandle inAlias)")}, 2007 {"FSIsAliasFile", (PyCFunction)FSRef_FSIsAliasFile, 1, 2008 PyDoc_STR("() -> (Boolean aliasFileFlag, Boolean folderFlag)")}, 2009 {"FSRefMakePath", (PyCFunction)FSRef_FSRefMakePath, 1, 2010 PyDoc_STR("() -> string")}, 2011 {"as_pathname", (PyCFunction)FSRef_as_pathname, 1, 2012 PyDoc_STR("() -> string")}, 2013 {NULL, NULL, 0} 2014 }; 2015 2016 static PyObject *FSRef_get_data(FSRefObject *self, void *closure) 2017 { 2018 return PyString_FromStringAndSize((char *)&self->ob_itself, sizeof(self->ob_itself)); 2019 } 2020 2021 #define FSRef_set_data NULL 2022 2023 static PyGetSetDef FSRef_getsetlist[] = { 2024 {"data", (getter)FSRef_get_data, (setter)FSRef_set_data, "Raw data of the FSRef object"}, 2025 {NULL, NULL, NULL, NULL}, 2026 }; 2027 2028 2029 #define FSRef_compare NULL 2030 2031 #define FSRef_repr NULL 2032 2033 #define FSRef_hash NULL 2034 static int FSRef_tp_init(PyObject *_self, PyObject *_args, PyObject *_kwds) 2035 { 2036 PyObject *v = NULL; 2037 char *rawdata = NULL; 2038 int rawdatalen = 0; 2039 static char *kw[] = {"itself", "rawdata", 0}; 2040 2041 if (!PyArg_ParseTupleAndKeywords(_args, _kwds, "|Os#", kw, &v, &rawdata, &rawdatalen)) 2042 return -1; 2043 if (v && rawdata) 2044 { 2045 PyErr_SetString(PyExc_TypeError, "Only one of itself or rawdata may be specified"); 2046 return -1; 2047 } 2048 if (!v && !rawdata) 2049 { 2050 PyErr_SetString(PyExc_TypeError, "One of itself or rawdata must be specified"); 2051 return -1; 2052 } 2053 if (rawdata) 2054 { 2055 if (rawdatalen != sizeof(FSRef)) 2056 { 2057 PyErr_SetString(PyExc_TypeError, "FSRef rawdata incorrect size"); 2058 return -1; 2059 } 2060 memcpy(&((FSRefObject *)_self)->ob_itself, rawdata, rawdatalen); 2061 return 0; 2062 } 2063 if (PyMac_GetFSRef(v, &((FSRefObject *)_self)->ob_itself)) return 0; 2064 return -1; 2065 } 2066 2067 #define FSRef_tp_alloc PyType_GenericAlloc 2068 2069 static PyObject *FSRef_tp_new(PyTypeObject *type, PyObject *_args, PyObject *_kwds) 2070 { 2071 PyObject *self; 2072 2073 if ((self = type->tp_alloc(type, 0)) == NULL) return NULL; 2074 memset(&((FSRefObject *)self)->ob_itself, 0, sizeof(FSRef)); 2075 return self; 2076 } 2077 2078 #define FSRef_tp_free PyObject_Del 2079 2080 2081 static PyTypeObject FSRef_Type = { 2082 PyObject_HEAD_INIT(NULL) 2083 0, /*ob_size*/ 2084 "Carbon.File.FSRef", /*tp_name*/ 2085 sizeof(FSRefObject), /*tp_basicsize*/ 2086 0, /*tp_itemsize*/ 2087 /* methods */ 2088 (destructor) FSRef_dealloc, /*tp_dealloc*/ 2089 0, /*tp_print*/ 2090 (getattrfunc)0, /*tp_getattr*/ 2091 (setattrfunc)0, /*tp_setattr*/ 2092 (cmpfunc) FSRef_compare, /*tp_compare*/ 2093 (reprfunc) FSRef_repr, /*tp_repr*/ 2094 (PyNumberMethods *)0, /* tp_as_number */ 2095 (PySequenceMethods *)0, /* tp_as_sequence */ 2096 (PyMappingMethods *)0, /* tp_as_mapping */ 2097 (hashfunc) FSRef_hash, /*tp_hash*/ 2098 0, /*tp_call*/ 2099 0, /*tp_str*/ 2100 PyObject_GenericGetAttr, /*tp_getattro*/ 2101 PyObject_GenericSetAttr, /*tp_setattro */ 2102 0, /*tp_as_buffer*/ 2103 Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */ 2104 0, /*tp_doc*/ 2105 0, /*tp_traverse*/ 2106 0, /*tp_clear*/ 2107 0, /*tp_richcompare*/ 2108 0, /*tp_weaklistoffset*/ 2109 0, /*tp_iter*/ 2110 0, /*tp_iternext*/ 2111 FSRef_methods, /* tp_methods */ 2112 0, /*tp_members*/ 2113 FSRef_getsetlist, /*tp_getset*/ 2114 0, /*tp_base*/ 2115 0, /*tp_dict*/ 2116 0, /*tp_descr_get*/ 2117 0, /*tp_descr_set*/ 2118 0, /*tp_dictoffset*/ 2119 FSRef_tp_init, /* tp_init */ 2120 FSRef_tp_alloc, /* tp_alloc */ 2121 FSRef_tp_new, /* tp_new */ 2122 FSRef_tp_free, /* tp_free */ 2123 }; 2124 2125 /* --------------------- End object type FSRef ---------------------- */ 2126 2127 #ifndef __LP64__ 2128 static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args) 2129 { 2130 PyObject *_res = NULL; 2131 OSErr _err; 2132 Str63 volName; 2133 short vRefNum; 2134 if (!PyArg_ParseTuple(_args, "O&h", 2135 PyMac_GetStr255, volName, 2136 &vRefNum)) 2137 return NULL; 2138 _err = UnmountVol(volName, 2139 vRefNum); 2140 if (_err != noErr) return PyMac_Error(_err); 2141 Py_INCREF(Py_None); 2142 _res = Py_None; 2143 return _res; 2144 } 2145 2146 static PyObject *File_FlushVol(PyObject *_self, PyObject *_args) 2147 { 2148 PyObject *_res = NULL; 2149 OSErr _err; 2150 Str63 volName; 2151 short vRefNum; 2152 if (!PyArg_ParseTuple(_args, "O&h", 2153 PyMac_GetStr255, volName, 2154 &vRefNum)) 2155 return NULL; 2156 _err = FlushVol(volName, 2157 vRefNum); 2158 if (_err != noErr) return PyMac_Error(_err); 2159 Py_INCREF(Py_None); 2160 _res = Py_None; 2161 return _res; 2162 } 2163 2164 static PyObject *File_HSetVol(PyObject *_self, PyObject *_args) 2165 { 2166 PyObject *_res = NULL; 2167 OSErr _err; 2168 Str63 volName; 2169 short vRefNum; 2170 long dirID; 2171 if (!PyArg_ParseTuple(_args, "O&hl", 2172 PyMac_GetStr255, volName, 2173 &vRefNum, 2174 &dirID)) 2175 return NULL; 2176 _err = HSetVol(volName, 2177 vRefNum, 2178 dirID); 2179 if (_err != noErr) return PyMac_Error(_err); 2180 Py_INCREF(Py_None); 2181 _res = Py_None; 2182 return _res; 2183 } 2184 2185 static PyObject *File_FSClose(PyObject *_self, PyObject *_args) 2186 { 2187 PyObject *_res = NULL; 2188 OSErr _err; 2189 short refNum; 2190 if (!PyArg_ParseTuple(_args, "h", 2191 &refNum)) 2192 return NULL; 2193 _err = FSClose(refNum); 2194 if (_err != noErr) return PyMac_Error(_err); 2195 Py_INCREF(Py_None); 2196 _res = Py_None; 2197 return _res; 2198 } 2199 2200 static PyObject *File_Allocate(PyObject *_self, PyObject *_args) 2201 { 2202 PyObject *_res = NULL; 2203 OSErr _err; 2204 short refNum; 2205 long count; 2206 if (!PyArg_ParseTuple(_args, "h", 2207 &refNum)) 2208 return NULL; 2209 _err = Allocate(refNum, 2210 &count); 2211 if (_err != noErr) return PyMac_Error(_err); 2212 _res = Py_BuildValue("l", 2213 count); 2214 return _res; 2215 } 2216 2217 static PyObject *File_GetEOF(PyObject *_self, PyObject *_args) 2218 { 2219 PyObject *_res = NULL; 2220 OSErr _err; 2221 short refNum; 2222 long logEOF; 2223 if (!PyArg_ParseTuple(_args, "h", 2224 &refNum)) 2225 return NULL; 2226 _err = GetEOF(refNum, 2227 &logEOF); 2228 if (_err != noErr) return PyMac_Error(_err); 2229 _res = Py_BuildValue("l", 2230 logEOF); 2231 return _res; 2232 } 2233 2234 static PyObject *File_SetEOF(PyObject *_self, PyObject *_args) 2235 { 2236 PyObject *_res = NULL; 2237 OSErr _err; 2238 short refNum; 2239 long logEOF; 2240 if (!PyArg_ParseTuple(_args, "hl", 2241 &refNum, 2242 &logEOF)) 2243 return NULL; 2244 _err = SetEOF(refNum, 2245 logEOF); 2246 if (_err != noErr) return PyMac_Error(_err); 2247 Py_INCREF(Py_None); 2248 _res = Py_None; 2249 return _res; 2250 } 2251 2252 static PyObject *File_GetFPos(PyObject *_self, PyObject *_args) 2253 { 2254 PyObject *_res = NULL; 2255 OSErr _err; 2256 short refNum; 2257 long filePos; 2258 if (!PyArg_ParseTuple(_args, "h", 2259 &refNum)) 2260 return NULL; 2261 _err = GetFPos(refNum, 2262 &filePos); 2263 if (_err != noErr) return PyMac_Error(_err); 2264 _res = Py_BuildValue("l", 2265 filePos); 2266 return _res; 2267 } 2268 2269 static PyObject *File_SetFPos(PyObject *_self, PyObject *_args) 2270 { 2271 PyObject *_res = NULL; 2272 OSErr _err; 2273 short refNum; 2274 short posMode; 2275 long posOff; 2276 if (!PyArg_ParseTuple(_args, "hhl", 2277 &refNum, 2278 &posMode, 2279 &posOff)) 2280 return NULL; 2281 _err = SetFPos(refNum, 2282 posMode, 2283 posOff); 2284 if (_err != noErr) return PyMac_Error(_err); 2285 Py_INCREF(Py_None); 2286 _res = Py_None; 2287 return _res; 2288 } 2289 2290 static PyObject *File_GetVRefNum(PyObject *_self, PyObject *_args) 2291 { 2292 PyObject *_res = NULL; 2293 OSErr _err; 2294 short fileRefNum; 2295 short vRefNum; 2296 if (!PyArg_ParseTuple(_args, "h", 2297 &fileRefNum)) 2298 return NULL; 2299 _err = GetVRefNum(fileRefNum, 2300 &vRefNum); 2301 if (_err != noErr) return PyMac_Error(_err); 2302 _res = Py_BuildValue("h", 2303 vRefNum); 2304 return _res; 2305 } 2306 2307 static PyObject *File_HGetVol(PyObject *_self, PyObject *_args) 2308 { 2309 PyObject *_res = NULL; 2310 OSErr _err; 2311 StringPtr volName; 2312 short vRefNum; 2313 long dirID; 2314 if (!PyArg_ParseTuple(_args, "O&", 2315 PyMac_GetStr255, &volName)) 2316 return NULL; 2317 _err = HGetVol(volName, 2318 &vRefNum, 2319 &dirID); 2320 if (_err != noErr) return PyMac_Error(_err); 2321 _res = Py_BuildValue("hl", 2322 vRefNum, 2323 dirID); 2324 return _res; 2325 } 2326 2327 static PyObject *File_HOpen(PyObject *_self, PyObject *_args) 2328 { 2329 PyObject *_res = NULL; 2330 OSErr _err; 2331 short vRefNum; 2332 long dirID; 2333 Str255 fileName; 2334 SInt8 permission; 2335 short refNum; 2336 if (!PyArg_ParseTuple(_args, "hlO&b", 2337 &vRefNum, 2338 &dirID, 2339 PyMac_GetStr255, fileName, 2340 &permission)) 2341 return NULL; 2342 _err = HOpen(vRefNum, 2343 dirID, 2344 fileName, 2345 permission, 2346 &refNum); 2347 if (_err != noErr) return PyMac_Error(_err); 2348 _res = Py_BuildValue("h", 2349 refNum); 2350 return _res; 2351 } 2352 2353 static PyObject *File_HOpenDF(PyObject *_self, PyObject *_args) 2354 { 2355 PyObject *_res = NULL; 2356 OSErr _err; 2357 short vRefNum; 2358 long dirID; 2359 Str255 fileName; 2360 SInt8 permission; 2361 short refNum; 2362 if (!PyArg_ParseTuple(_args, "hlO&b", 2363 &vRefNum, 2364 &dirID, 2365 PyMac_GetStr255, fileName, 2366 &permission)) 2367 return NULL; 2368 _err = HOpenDF(vRefNum, 2369 dirID, 2370 fileName, 2371 permission, 2372 &refNum); 2373 if (_err != noErr) return PyMac_Error(_err); 2374 _res = Py_BuildValue("h", 2375 refNum); 2376 return _res; 2377 } 2378 2379 static PyObject *File_HOpenRF(PyObject *_self, PyObject *_args) 2380 { 2381 PyObject *_res = NULL; 2382 OSErr _err; 2383 short vRefNum; 2384 long dirID; 2385 Str255 fileName; 2386 SInt8 permission; 2387 short refNum; 2388 if (!PyArg_ParseTuple(_args, "hlO&b", 2389 &vRefNum, 2390 &dirID, 2391 PyMac_GetStr255, fileName, 2392 &permission)) 2393 return NULL; 2394 _err = HOpenRF(vRefNum, 2395 dirID, 2396 fileName, 2397 permission, 2398 &refNum); 2399 if (_err != noErr) return PyMac_Error(_err); 2400 _res = Py_BuildValue("h", 2401 refNum); 2402 return _res; 2403 } 2404 2405 static PyObject *File_AllocContig(PyObject *_self, PyObject *_args) 2406 { 2407 PyObject *_res = NULL; 2408 OSErr _err; 2409 short refNum; 2410 long count; 2411 if (!PyArg_ParseTuple(_args, "h", 2412 &refNum)) 2413 return NULL; 2414 _err = AllocContig(refNum, 2415 &count); 2416 if (_err != noErr) return PyMac_Error(_err); 2417 _res = Py_BuildValue("l", 2418 count); 2419 return _res; 2420 } 2421 2422 static PyObject *File_HCreate(PyObject *_self, PyObject *_args) 2423 { 2424 PyObject *_res = NULL; 2425 OSErr _err; 2426 short vRefNum; 2427 long dirID; 2428 Str255 fileName; 2429 OSType creator; 2430 OSType fileType; 2431 if (!PyArg_ParseTuple(_args, "hlO&O&O&", 2432 &vRefNum, 2433 &dirID, 2434 PyMac_GetStr255, fileName, 2435 PyMac_GetOSType, &creator, 2436 PyMac_GetOSType, &fileType)) 2437 return NULL; 2438 _err = HCreate(vRefNum, 2439 dirID, 2440 fileName, 2441 creator, 2442 fileType); 2443 if (_err != noErr) return PyMac_Error(_err); 2444 Py_INCREF(Py_None); 2445 _res = Py_None; 2446 return _res; 2447 } 2448 2449 static PyObject *File_DirCreate(PyObject *_self, PyObject *_args) 2450 { 2451 PyObject *_res = NULL; 2452 OSErr _err; 2453 short vRefNum; 2454 long parentDirID; 2455 Str255 directoryName; 2456 long createdDirID; 2457 if (!PyArg_ParseTuple(_args, "hlO&", 2458 &vRefNum, 2459 &parentDirID, 2460 PyMac_GetStr255, directoryName)) 2461 return NULL; 2462 _err = DirCreate(vRefNum, 2463 parentDirID, 2464 directoryName, 2465 &createdDirID); 2466 if (_err != noErr) return PyMac_Error(_err); 2467 _res = Py_BuildValue("l", 2468 createdDirID); 2469 return _res; 2470 } 2471 2472 static PyObject *File_HDelete(PyObject *_self, PyObject *_args) 2473 { 2474 PyObject *_res = NULL; 2475 OSErr _err; 2476 short vRefNum; 2477 long dirID; 2478 Str255 fileName; 2479 if (!PyArg_ParseTuple(_args, "hlO&", 2480 &vRefNum, 2481 &dirID, 2482 PyMac_GetStr255, fileName)) 2483 return NULL; 2484 _err = HDelete(vRefNum, 2485 dirID, 2486 fileName); 2487 if (_err != noErr) return PyMac_Error(_err); 2488 Py_INCREF(Py_None); 2489 _res = Py_None; 2490 return _res; 2491 } 2492 2493 static PyObject *File_HGetFInfo(PyObject *_self, PyObject *_args) 2494 { 2495 PyObject *_res = NULL; 2496 OSErr _err; 2497 short vRefNum; 2498 long dirID; 2499 Str255 fileName; 2500 FInfo fndrInfo; 2501 if (!PyArg_ParseTuple(_args, "hlO&", 2502 &vRefNum, 2503 &dirID, 2504 PyMac_GetStr255, fileName)) 2505 return NULL; 2506 _err = HGetFInfo(vRefNum, 2507 dirID, 2508 fileName, 2509 &fndrInfo); 2510 if (_err != noErr) return PyMac_Error(_err); 2511 _res = Py_BuildValue("O&", 2512 FInfo_New, &fndrInfo); 2513 return _res; 2514 } 2515 2516 static PyObject *File_HSetFInfo(PyObject *_self, PyObject *_args) 2517 { 2518 PyObject *_res = NULL; 2519 OSErr _err; 2520 short vRefNum; 2521 long dirID; 2522 Str255 fileName; 2523 FInfo fndrInfo; 2524 if (!PyArg_ParseTuple(_args, "hlO&O&", 2525 &vRefNum, 2526 &dirID, 2527 PyMac_GetStr255, fileName, 2528 FInfo_Convert, &fndrInfo)) 2529 return NULL; 2530 _err = HSetFInfo(vRefNum, 2531 dirID, 2532 fileName, 2533 &fndrInfo); 2534 if (_err != noErr) return PyMac_Error(_err); 2535 Py_INCREF(Py_None); 2536 _res = Py_None; 2537 return _res; 2538 } 2539 2540 static PyObject *File_HSetFLock(PyObject *_self, PyObject *_args) 2541 { 2542 PyObject *_res = NULL; 2543 OSErr _err; 2544 short vRefNum; 2545 long dirID; 2546 Str255 fileName; 2547 if (!PyArg_ParseTuple(_args, "hlO&", 2548 &vRefNum, 2549 &dirID, 2550 PyMac_GetStr255, fileName)) 2551 return NULL; 2552 _err = HSetFLock(vRefNum, 2553 dirID, 2554 fileName); 2555 if (_err != noErr) return PyMac_Error(_err); 2556 Py_INCREF(Py_None); 2557 _res = Py_None; 2558 return _res; 2559 } 2560 2561 static PyObject *File_HRstFLock(PyObject *_self, PyObject *_args) 2562 { 2563 PyObject *_res = NULL; 2564 OSErr _err; 2565 short vRefNum; 2566 long dirID; 2567 Str255 fileName; 2568 if (!PyArg_ParseTuple(_args, "hlO&", 2569 &vRefNum, 2570 &dirID, 2571 PyMac_GetStr255, fileName)) 2572 return NULL; 2573 _err = HRstFLock(vRefNum, 2574 dirID, 2575 fileName); 2576 if (_err != noErr) return PyMac_Error(_err); 2577 Py_INCREF(Py_None); 2578 _res = Py_None; 2579 return _res; 2580 } 2581 2582 static PyObject *File_HRename(PyObject *_self, PyObject *_args) 2583 { 2584 PyObject *_res = NULL; 2585 OSErr _err; 2586 short vRefNum; 2587 long dirID; 2588 Str255 oldName; 2589 Str255 newName; 2590 if (!PyArg_ParseTuple(_args, "hlO&O&", 2591 &vRefNum, 2592 &dirID, 2593 PyMac_GetStr255, oldName, 2594 PyMac_GetStr255, newName)) 2595 return NULL; 2596 _err = HRename(vRefNum, 2597 dirID, 2598 oldName, 2599 newName); 2600 if (_err != noErr) return PyMac_Error(_err); 2601 Py_INCREF(Py_None); 2602 _res = Py_None; 2603 return _res; 2604 } 2605 2606 static PyObject *File_CatMove(PyObject *_self, PyObject *_args) 2607 { 2608 PyObject *_res = NULL; 2609 OSErr _err; 2610 short vRefNum; 2611 long dirID; 2612 Str255 oldName; 2613 long newDirID; 2614 Str255 newName; 2615 if (!PyArg_ParseTuple(_args, "hlO&lO&", 2616 &vRefNum, 2617 &dirID, 2618 PyMac_GetStr255, oldName, 2619 &newDirID, 2620 PyMac_GetStr255, newName)) 2621 return NULL; 2622 _err = CatMove(vRefNum, 2623 dirID, 2624 oldName, 2625 newDirID, 2626 newName); 2627 if (_err != noErr) return PyMac_Error(_err); 2628 Py_INCREF(Py_None); 2629 _res = Py_None; 2630 return _res; 2631 } 2632 2633 static PyObject *File_FSMakeFSSpec(PyObject *_self, PyObject *_args) 2634 { 2635 PyObject *_res = NULL; 2636 OSErr _err; 2637 short vRefNum; 2638 long dirID; 2639 Str255 fileName; 2640 FSSpec spec; 2641 if (!PyArg_ParseTuple(_args, "hlO&", 2642 &vRefNum, 2643 &dirID, 2644 PyMac_GetStr255, fileName)) 2645 return NULL; 2646 _err = FSMakeFSSpec(vRefNum, 2647 dirID, 2648 fileName, 2649 &spec); 2650 if (_err != noErr) return PyMac_Error(_err); 2651 _res = Py_BuildValue("O&", 2652 FSSpec_New, &spec); 2653 return _res; 2654 } 2655 #endif /* !__LP64__ */ 2656 2657 static PyObject *File_FSGetForkPosition(PyObject *_self, PyObject *_args) 2658 { 2659 PyObject *_res = NULL; 2660 OSErr _err; 2661 SInt16 forkRefNum; 2662 SInt64 position; 2663 if (!PyArg_ParseTuple(_args, "h", 2664 &forkRefNum)) 2665 return NULL; 2666 _err = FSGetForkPosition(forkRefNum, 2667 &position); 2668 if (_err != noErr) return PyMac_Error(_err); 2669 _res = Py_BuildValue("L", 2670 position); 2671 return _res; 2672 } 2673 2674 static PyObject *File_FSSetForkPosition(PyObject *_self, PyObject *_args) 2675 { 2676 PyObject *_res = NULL; 2677 OSErr _err; 2678 SInt16 forkRefNum; 2679 UInt16 positionMode; 2680 SInt64 positionOffset; 2681 if (!PyArg_ParseTuple(_args, "hHL", 2682 &forkRefNum, 2683 &positionMode, 2684 &positionOffset)) 2685 return NULL; 2686 _err = FSSetForkPosition(forkRefNum, 2687 positionMode, 2688 positionOffset); 2689 if (_err != noErr) return PyMac_Error(_err); 2690 Py_INCREF(Py_None); 2691 _res = Py_None; 2692 return _res; 2693 } 2694 2695 static PyObject *File_FSGetForkSize(PyObject *_self, PyObject *_args) 2696 { 2697 PyObject *_res = NULL; 2698 OSErr _err; 2699 SInt16 forkRefNum; 2700 SInt64 forkSize; 2701 if (!PyArg_ParseTuple(_args, "h", 2702 &forkRefNum)) 2703 return NULL; 2704 _err = FSGetForkSize(forkRefNum, 2705 &forkSize); 2706 if (_err != noErr) return PyMac_Error(_err); 2707 _res = Py_BuildValue("L", 2708 forkSize); 2709 return _res; 2710 } 2711 2712 static PyObject *File_FSSetForkSize(PyObject *_self, PyObject *_args) 2713 { 2714 PyObject *_res = NULL; 2715 OSErr _err; 2716 SInt16 forkRefNum; 2717 UInt16 positionMode; 2718 SInt64 positionOffset; 2719 if (!PyArg_ParseTuple(_args, "hHL", 2720 &forkRefNum, 2721 &positionMode, 2722 &positionOffset)) 2723 return NULL; 2724 _err = FSSetForkSize(forkRefNum, 2725 positionMode, 2726 positionOffset); 2727 if (_err != noErr) return PyMac_Error(_err); 2728 Py_INCREF(Py_None); 2729 _res = Py_None; 2730 return _res; 2731 } 2732 2733 static PyObject *File_FSAllocateFork(PyObject *_self, PyObject *_args) 2734 { 2735 PyObject *_res = NULL; 2736 OSErr _err; 2737 SInt16 forkRefNum; 2738 FSAllocationFlags flags; 2739 UInt16 positionMode; 2740 SInt64 positionOffset; 2741 UInt64 requestCount; 2742 UInt64 actualCount; 2743 if (!PyArg_ParseTuple(_args, "hHHLL", 2744 &forkRefNum, 2745 &flags, 2746 &positionMode, 2747 &positionOffset, 2748 &requestCount)) 2749 return NULL; 2750 _err = FSAllocateFork(forkRefNum, 2751 flags, 2752 positionMode, 2753 positionOffset, 2754 requestCount, 2755 &actualCount); 2756 if (_err != noErr) return PyMac_Error(_err); 2757 _res = Py_BuildValue("L", 2758 actualCount); 2759 return _res; 2760 } 2761 2762 static PyObject *File_FSFlushFork(PyObject *_self, PyObject *_args) 2763 { 2764 PyObject *_res = NULL; 2765 OSErr _err; 2766 SInt16 forkRefNum; 2767 if (!PyArg_ParseTuple(_args, "h", 2768 &forkRefNum)) 2769 return NULL; 2770 _err = FSFlushFork(forkRefNum); 2771 if (_err != noErr) return PyMac_Error(_err); 2772 Py_INCREF(Py_None); 2773 _res = Py_None; 2774 return _res; 2775 } 2776 2777 static PyObject *File_FSCloseFork(PyObject *_self, PyObject *_args) 2778 { 2779 PyObject *_res = NULL; 2780 OSErr _err; 2781 SInt16 forkRefNum; 2782 if (!PyArg_ParseTuple(_args, "h", 2783 &forkRefNum)) 2784 return NULL; 2785 _err = FSCloseFork(forkRefNum); 2786 if (_err != noErr) return PyMac_Error(_err); 2787 Py_INCREF(Py_None); 2788 _res = Py_None; 2789 return _res; 2790 } 2791 2792 static PyObject *File_FSGetDataForkName(PyObject *_self, PyObject *_args) 2793 { 2794 PyObject *_res = NULL; 2795 OSErr _err; 2796 HFSUniStr255 dataForkName; 2797 if (!PyArg_ParseTuple(_args, "")) 2798 return NULL; 2799 _err = FSGetDataForkName(&dataForkName); 2800 if (_err != noErr) return PyMac_Error(_err); 2801 _res = Py_BuildValue("O&", 2802 PyMac_BuildHFSUniStr255, &dataForkName); 2803 return _res; 2804 } 2805 2806 static PyObject *File_FSGetResourceForkName(PyObject *_self, PyObject *_args) 2807 { 2808 PyObject *_res = NULL; 2809 OSErr _err; 2810 HFSUniStr255 resourceForkName; 2811 if (!PyArg_ParseTuple(_args, "")) 2812 return NULL; 2813 _err = FSGetResourceForkName(&resourceForkName); 2814 if (_err != noErr) return PyMac_Error(_err); 2815 _res = Py_BuildValue("O&", 2816 PyMac_BuildHFSUniStr255, &resourceForkName); 2817 return _res; 2818 } 2819 2820 static PyObject *File_FSPathMakeRef(PyObject *_self, PyObject *_args) 2821 { 2822 PyObject *_res = NULL; 2823 OSStatus _err; 2824 UInt8 * path; 2825 FSRef ref; 2826 Boolean isDirectory; 2827 if (!PyArg_ParseTuple(_args, "s", 2828 &path)) 2829 return NULL; 2830 _err = FSPathMakeRef(path, 2831 &ref, 2832 &isDirectory); 2833 if (_err != noErr) return PyMac_Error(_err); 2834 _res = Py_BuildValue("O&b", 2835 FSRef_New, &ref, 2836 isDirectory); 2837 return _res; 2838 } 2839 2840 static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args) 2841 { 2842 PyObject *_res = NULL; 2843 OSStatus _err; 2844 UInt8 * path; 2845 FNMessage message; 2846 OptionBits flags; 2847 if (!PyArg_ParseTuple(_args, "sll", 2848 &path, 2849 &message, 2850 &flags)) 2851 return NULL; 2852 _err = FNNotifyByPath(path, 2853 message, 2854 flags); 2855 if (_err != noErr) return PyMac_Error(_err); 2856 Py_INCREF(Py_None); 2857 _res = Py_None; 2858 return _res; 2859 } 2860 2861 static PyObject *File_FNNotifyAll(PyObject *_self, PyObject *_args) 2862 { 2863 PyObject *_res = NULL; 2864 OSStatus _err; 2865 FNMessage message; 2866 OptionBits flags; 2867 if (!PyArg_ParseTuple(_args, "ll", 2868 &message, 2869 &flags)) 2870 return NULL; 2871 _err = FNNotifyAll(message, 2872 flags); 2873 if (_err != noErr) return PyMac_Error(_err); 2874 Py_INCREF(Py_None); 2875 _res = Py_None; 2876 return _res; 2877 } 2878 2879 #ifndef __LP64__ 2880 static PyObject *File_NewAlias(PyObject *_self, PyObject *_args) 2881 { 2882 PyObject *_res = NULL; 2883 OSErr _err; 2884 FSSpec fromFile__buf__; 2885 FSSpec *fromFile = &fromFile__buf__; 2886 FSSpec target; 2887 AliasHandle alias; 2888 if (!PyArg_ParseTuple(_args, "O&O&", 2889 myPyMac_GetOptFSSpecPtr, &fromFile, 2890 FSSpec_Convert, &target)) 2891 return NULL; 2892 _err = NewAlias(fromFile, 2893 &target, 2894 &alias); 2895 if (_err != noErr) return PyMac_Error(_err); 2896 _res = Py_BuildValue("O&", 2897 Alias_New, alias); 2898 return _res; 2899 } 2900 2901 static PyObject *File_NewAliasMinimalFromFullPath(PyObject *_self, PyObject *_args) 2902 { 2903 PyObject *_res = NULL; 2904 OSErr _err; 2905 char *fullPath__in__; 2906 int fullPath__len__; 2907 int fullPath__in_len__; 2908 Str32 zoneName; 2909 Str31 serverName; 2910 AliasHandle alias; 2911 if (!PyArg_ParseTuple(_args, "s#O&O&", 2912 &fullPath__in__, &fullPath__in_len__, 2913 PyMac_GetStr255, zoneName, 2914 PyMac_GetStr255, serverName)) 2915 return NULL; 2916 fullPath__len__ = fullPath__in_len__; 2917 _err = NewAliasMinimalFromFullPath(fullPath__len__, fullPath__in__, 2918 zoneName, 2919 serverName, 2920 &alias); 2921 if (_err != noErr) return PyMac_Error(_err); 2922 _res = Py_BuildValue("O&", 2923 Alias_New, alias); 2924 return _res; 2925 } 2926 2927 static PyObject *File_ResolveAliasFile(PyObject *_self, PyObject *_args) 2928 { 2929 PyObject *_res = NULL; 2930 OSErr _err; 2931 FSSpec theSpec; 2932 Boolean resolveAliasChains; 2933 Boolean targetIsFolder; 2934 Boolean wasAliased; 2935 if (!PyArg_ParseTuple(_args, "O&b", 2936 FSSpec_Convert, &theSpec, 2937 &resolveAliasChains)) 2938 return NULL; 2939 _err = ResolveAliasFile(&theSpec, 2940 resolveAliasChains, 2941 &targetIsFolder, 2942 &wasAliased); 2943 if (_err != noErr) return PyMac_Error(_err); 2944 _res = Py_BuildValue("O&bb", 2945 FSSpec_New, &theSpec, 2946 targetIsFolder, 2947 wasAliased); 2948 return _res; 2949 } 2950 2951 static PyObject *File_ResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args) 2952 { 2953 PyObject *_res = NULL; 2954 OSErr _err; 2955 FSSpec theSpec; 2956 Boolean resolveAliasChains; 2957 Boolean targetIsFolder; 2958 Boolean wasAliased; 2959 unsigned long mountFlags; 2960 if (!PyArg_ParseTuple(_args, "O&bl", 2961 FSSpec_Convert, &theSpec, 2962 &resolveAliasChains, 2963 &mountFlags)) 2964 return NULL; 2965 _err = ResolveAliasFileWithMountFlags(&theSpec, 2966 resolveAliasChains, 2967 &targetIsFolder, 2968 &wasAliased, 2969 mountFlags); 2970 if (_err != noErr) return PyMac_Error(_err); 2971 _res = Py_BuildValue("O&bb", 2972 FSSpec_New, &theSpec, 2973 targetIsFolder, 2974 wasAliased); 2975 return _res; 2976 } 2977 2978 static PyObject *File_UpdateAlias(PyObject *_self, PyObject *_args) 2979 { 2980 PyObject *_res = NULL; 2981 OSErr _err; 2982 FSSpec fromFile__buf__; 2983 FSSpec *fromFile = &fromFile__buf__; 2984 FSSpec target; 2985 AliasHandle alias; 2986 Boolean wasChanged; 2987 if (!PyArg_ParseTuple(_args, "O&O&O&", 2988 myPyMac_GetOptFSSpecPtr, &fromFile, 2989 FSSpec_Convert, &target, 2990 Alias_Convert, &alias)) 2991 return NULL; 2992 _err = UpdateAlias(fromFile, 2993 &target, 2994 alias, 2995 &wasChanged); 2996 if (_err != noErr) return PyMac_Error(_err); 2997 _res = Py_BuildValue("b", 2998 wasChanged); 2999 return _res; 3000 } 3001 3002 static PyObject *File_ResolveAliasFileWithMountFlagsNoUI(PyObject *_self, PyObject *_args) 3003 { 3004 PyObject *_res = NULL; 3005 OSErr _err; 3006 FSSpec theSpec; 3007 Boolean resolveAliasChains; 3008 Boolean targetIsFolder; 3009 Boolean wasAliased; 3010 unsigned long mountFlags; 3011 if (!PyArg_ParseTuple(_args, "O&bl", 3012 FSSpec_Convert, &theSpec, 3013 &resolveAliasChains, 3014 &mountFlags)) 3015 return NULL; 3016 _err = ResolveAliasFileWithMountFlagsNoUI(&theSpec, 3017 resolveAliasChains, 3018 &targetIsFolder, 3019 &wasAliased, 3020 mountFlags); 3021 if (_err != noErr) return PyMac_Error(_err); 3022 _res = Py_BuildValue("O&bb", 3023 FSSpec_New, &theSpec, 3024 targetIsFolder, 3025 wasAliased); 3026 return _res; 3027 } 3028 #endif /* !__LP64__ */ 3029 3030 static PyObject *File_FSNewAlias(PyObject *_self, PyObject *_args) 3031 { 3032 PyObject *_res = NULL; 3033 OSErr _err; 3034 FSRef fromFile__buf__; 3035 FSRef *fromFile = &fromFile__buf__; 3036 FSRef target; 3037 AliasHandle inAlias; 3038 if (!PyArg_ParseTuple(_args, "O&O&", 3039 myPyMac_GetOptFSRefPtr, &fromFile, 3040 FSRef_Convert, &target)) 3041 return NULL; 3042 _err = FSNewAlias(fromFile, 3043 &target, 3044 &inAlias); 3045 if (_err != noErr) return PyMac_Error(_err); 3046 _res = Py_BuildValue("O&", 3047 Alias_New, inAlias); 3048 return _res; 3049 } 3050 3051 static PyObject *File_FSResolveAliasFileWithMountFlags(PyObject *_self, PyObject *_args) 3052 { 3053 PyObject *_res = NULL; 3054 OSErr _err; 3055 FSRef theRef; 3056 Boolean resolveAliasChains; 3057 Boolean targetIsFolder; 3058 Boolean wasAliased; 3059 unsigned long mountFlags; 3060 if (!PyArg_ParseTuple(_args, "O&bl", 3061 FSRef_Convert, &theRef, 3062 &resolveAliasChains, 3063 &mountFlags)) 3064 return NULL; 3065 _err = FSResolveAliasFileWithMountFlags(&theRef, 3066 resolveAliasChains, 3067 &targetIsFolder, 3068 &wasAliased, 3069 mountFlags); 3070 if (_err != noErr) return PyMac_Error(_err); 3071 _res = Py_BuildValue("O&bb", 3072 FSRef_New, &theRef, 3073 targetIsFolder, 3074 wasAliased); 3075 return _res; 3076 } 3077 3078 static PyObject *File_FSResolveAliasFile(PyObject *_self, PyObject *_args) 3079 { 3080 PyObject *_res = NULL; 3081 OSErr _err; 3082 FSRef theRef; 3083 Boolean resolveAliasChains; 3084 Boolean targetIsFolder; 3085 Boolean wasAliased; 3086 if (!PyArg_ParseTuple(_args, "O&b", 3087 FSRef_Convert, &theRef, 3088 &resolveAliasChains)) 3089 return NULL; 3090 _err = FSResolveAliasFile(&theRef, 3091 resolveAliasChains, 3092 &targetIsFolder, 3093 &wasAliased); 3094 if (_err != noErr) return PyMac_Error(_err); 3095 _res = Py_BuildValue("O&bb", 3096 FSRef_New, &theRef, 3097 targetIsFolder, 3098 wasAliased); 3099 return _res; 3100 } 3101 3102 static PyObject *File_FSUpdateAlias(PyObject *_self, PyObject *_args) 3103 { 3104 PyObject *_res = NULL; 3105 OSErr _err; 3106 FSRef fromFile__buf__; 3107 FSRef *fromFile = &fromFile__buf__; 3108 FSRef target; 3109 AliasHandle alias; 3110 Boolean wasChanged; 3111 if (!PyArg_ParseTuple(_args, "O&O&O&", 3112 myPyMac_GetOptFSRefPtr, &fromFile, 3113 FSRef_Convert, &target, 3114 Alias_Convert, &alias)) 3115 return NULL; 3116 _err = FSUpdateAlias(fromFile, 3117 &target, 3118 alias, 3119 &wasChanged); 3120 if (_err != noErr) return PyMac_Error(_err); 3121 _res = Py_BuildValue("b", 3122 wasChanged); 3123 return _res; 3124 } 3125 3126 static PyObject *File_pathname(PyObject *_self, PyObject *_args) 3127 { 3128 PyObject *_res = NULL; 3129 3130 PyObject *obj; 3131 3132 if (!PyArg_ParseTuple(_args, "O", &obj)) 3133 return NULL; 3134 if (PyString_Check(obj)) { 3135 Py_INCREF(obj); 3136 return obj; 3137 } 3138 if (PyUnicode_Check(obj)) 3139 return PyUnicode_AsEncodedString(obj, "utf8", "strict"); 3140 _res = PyObject_CallMethod(obj, "as_pathname", NULL); 3141 return _res; 3142 3143 } 3144 3145 static PyMethodDef File_methods[] = { 3146 #ifndef __LP64__ 3147 {"UnmountVol", (PyCFunction)File_UnmountVol, 1, 3148 PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, 3149 {"FlushVol", (PyCFunction)File_FlushVol, 1, 3150 PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, 3151 {"HSetVol", (PyCFunction)File_HSetVol, 1, 3152 PyDoc_STR("(Str63 volName, short vRefNum, long dirID) -> None")}, 3153 {"FSClose", (PyCFunction)File_FSClose, 1, 3154 PyDoc_STR("(short refNum) -> None")}, 3155 {"Allocate", (PyCFunction)File_Allocate, 1, 3156 PyDoc_STR("(short refNum) -> (long count)")}, 3157 {"GetEOF", (PyCFunction)File_GetEOF, 1, 3158 PyDoc_STR("(short refNum) -> (long logEOF)")}, 3159 {"SetEOF", (PyCFunction)File_SetEOF, 1, 3160 PyDoc_STR("(short refNum, long logEOF) -> None")}, 3161 {"GetFPos", (PyCFunction)File_GetFPos, 1, 3162 PyDoc_STR("(short refNum) -> (long filePos)")}, 3163 {"SetFPos", (PyCFunction)File_SetFPos, 1, 3164 PyDoc_STR("(short refNum, short posMode, long posOff) -> None")}, 3165 {"GetVRefNum", (PyCFunction)File_GetVRefNum, 1, 3166 PyDoc_STR("(short fileRefNum) -> (short vRefNum)")}, 3167 {"HGetVol", (PyCFunction)File_HGetVol, 1, 3168 PyDoc_STR("(StringPtr volName) -> (short vRefNum, long dirID)")}, 3169 {"HOpen", (PyCFunction)File_HOpen, 1, 3170 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, 3171 {"HOpenDF", (PyCFunction)File_HOpenDF, 1, 3172 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, 3173 {"HOpenRF", (PyCFunction)File_HOpenRF, 1, 3174 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, 3175 {"AllocContig", (PyCFunction)File_AllocContig, 1, 3176 PyDoc_STR("(short refNum) -> (long count)")}, 3177 {"HCreate", (PyCFunction)File_HCreate, 1, 3178 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, OSType creator, OSType fileType) -> None")}, 3179 {"DirCreate", (PyCFunction)File_DirCreate, 1, 3180 PyDoc_STR("(short vRefNum, long parentDirID, Str255 directoryName) -> (long createdDirID)")}, 3181 {"HDelete", (PyCFunction)File_HDelete, 1, 3182 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, 3183 {"HGetFInfo", (PyCFunction)File_HGetFInfo, 1, 3184 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FInfo fndrInfo)")}, 3185 {"HSetFInfo", (PyCFunction)File_HSetFInfo, 1, 3186 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, FInfo fndrInfo) -> None")}, 3187 {"HSetFLock", (PyCFunction)File_HSetFLock, 1, 3188 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, 3189 {"HRstFLock", (PyCFunction)File_HRstFLock, 1, 3190 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, 3191 {"HRename", (PyCFunction)File_HRename, 1, 3192 PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, Str255 newName) -> None")}, 3193 {"CatMove", (PyCFunction)File_CatMove, 1, 3194 PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, long newDirID, Str255 newName) -> None")}, 3195 {"FSMakeFSSpec", (PyCFunction)File_FSMakeFSSpec, 1, 3196 PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FSSpec spec)")}, 3197 #endif /* !__LP64__*/ 3198 {"FSGetForkPosition", (PyCFunction)File_FSGetForkPosition, 1, 3199 PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 position)")}, 3200 {"FSSetForkPosition", (PyCFunction)File_FSSetForkPosition, 1, 3201 PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, 3202 {"FSGetForkSize", (PyCFunction)File_FSGetForkSize, 1, 3203 PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 forkSize)")}, 3204 {"FSSetForkSize", (PyCFunction)File_FSSetForkSize, 1, 3205 PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, 3206 {"FSAllocateFork", (PyCFunction)File_FSAllocateFork, 1, 3207 PyDoc_STR("(SInt16 forkRefNum, FSAllocationFlags flags, UInt16 positionMode, SInt64 positionOffset, UInt64 requestCount) -> (UInt64 actualCount)")}, 3208 {"FSFlushFork", (PyCFunction)File_FSFlushFork, 1, 3209 PyDoc_STR("(SInt16 forkRefNum) -> None")}, 3210 {"FSCloseFork", (PyCFunction)File_FSCloseFork, 1, 3211 PyDoc_STR("(SInt16 forkRefNum) -> None")}, 3212 {"FSGetDataForkName", (PyCFunction)File_FSGetDataForkName, 1, 3213 PyDoc_STR("() -> (HFSUniStr255 dataForkName)")}, 3214 {"FSGetResourceForkName", (PyCFunction)File_FSGetResourceForkName, 1, 3215 PyDoc_STR("() -> (HFSUniStr255 resourceForkName)")}, 3216 {"FSPathMakeRef", (PyCFunction)File_FSPathMakeRef, 1, 3217 PyDoc_STR("(UInt8 * path) -> (FSRef ref, Boolean isDirectory)")}, 3218 {"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1, 3219 PyDoc_STR("(UInt8 * path, FNMessage message, OptionBits flags) -> None")}, 3220 {"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1, 3221 PyDoc_STR("(FNMessage message, OptionBits flags) -> None")}, 3222 #ifndef __LP64__ 3223 {"NewAlias", (PyCFunction)File_NewAlias, 1, 3224 PyDoc_STR("(FSSpec fromFile, FSSpec target) -> (AliasHandle alias)")}, 3225 {"NewAliasMinimalFromFullPath", (PyCFunction)File_NewAliasMinimalFromFullPath, 1, 3226 PyDoc_STR("(Buffer fullPath, Str32 zoneName, Str31 serverName) -> (AliasHandle alias)")}, 3227 {"ResolveAliasFile", (PyCFunction)File_ResolveAliasFile, 1, 3228 PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, 3229 {"ResolveAliasFileWithMountFlags", (PyCFunction)File_ResolveAliasFileWithMountFlags, 1, 3230 PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, 3231 {"UpdateAlias", (PyCFunction)File_UpdateAlias, 1, 3232 PyDoc_STR("(FSSpec fromFile, FSSpec target, AliasHandle alias) -> (Boolean wasChanged)")}, 3233 {"ResolveAliasFileWithMountFlagsNoUI", (PyCFunction)File_ResolveAliasFileWithMountFlagsNoUI, 1, 3234 PyDoc_STR("(FSSpec theSpec, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSSpec theSpec, Boolean targetIsFolder, Boolean wasAliased)")}, 3235 #endif /* !__LP64__ */ 3236 {"FSNewAlias", (PyCFunction)File_FSNewAlias, 1, 3237 PyDoc_STR("(FSRef fromFile, FSRef target) -> (AliasHandle inAlias)")}, 3238 {"FSResolveAliasFileWithMountFlags", (PyCFunction)File_FSResolveAliasFileWithMountFlags, 1, 3239 PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains, unsigned long mountFlags) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")}, 3240 {"FSResolveAliasFile", (PyCFunction)File_FSResolveAliasFile, 1, 3241 PyDoc_STR("(FSRef theRef, Boolean resolveAliasChains) -> (FSRef theRef, Boolean targetIsFolder, Boolean wasAliased)")}, 3242 {"FSUpdateAlias", (PyCFunction)File_FSUpdateAlias, 1, 3243 PyDoc_STR("(FSRef fromFile, FSRef target, AliasHandle alias) -> (Boolean wasChanged)")}, 3244 {"pathname", (PyCFunction)File_pathname, 1, 3245 PyDoc_STR("(str|unicode|FSSpec|FSref) -> pathname")}, 3246 {NULL, NULL, 0} 3247 }; 3248 3249 3250 #ifndef __LP64__ 3251 int 3252 PyMac_GetFSSpec(PyObject *v, FSSpec *spec) 3253 { 3254 Str255 path; 3255 short refnum; 3256 long parid; 3257 OSErr err; 3258 FSRef fsr; 3259 3260 if (FSSpec_Check(v)) { 3261 *spec = ((FSSpecObject *)v)->ob_itself; 3262 return 1; 3263 } 3264 3265 if (PyArg_Parse(v, "(hlO&)", 3266 &refnum, &parid, PyMac_GetStr255, &path)) { 3267 err = FSMakeFSSpec(refnum, parid, path, spec); 3268 if ( err && err != fnfErr ) { 3269 PyMac_Error(err); 3270 return 0; 3271 } 3272 return 1; 3273 } 3274 PyErr_Clear(); 3275 /* Otherwise we try to go via an FSRef. On OSX we go all the way, 3276 ** on OS9 we accept only a real FSRef object 3277 */ 3278 if ( PyMac_GetFSRef(v, &fsr) ) { 3279 err = FSGetCatalogInfo(&fsr, kFSCatInfoNone, NULL, NULL, spec, NULL); 3280 if (err != noErr) { 3281 PyMac_Error(err); 3282 return 0; 3283 } 3284 return 1; 3285 } 3286 return 0; 3287 } 3288 #endif /* !__LP64__ */ 3289 3290 int 3291 PyMac_GetFSRef(PyObject *v, FSRef *fsr) 3292 { 3293 OSStatus err; 3294 #ifndef __LP64__ 3295 FSSpec fss; 3296 #endif /* !__LP64__ */ 3297 3298 if (FSRef_Check(v)) { 3299 *fsr = ((FSRefObject *)v)->ob_itself; 3300 return 1; 3301 } 3302 3303 /* On OSX we now try a pathname */ 3304 if ( PyString_Check(v) || PyUnicode_Check(v)) { 3305 char *path = NULL; 3306 if (!PyArg_Parse(v, "et", Py_FileSystemDefaultEncoding, &path)) 3307 return 0; 3308 if ( (err=FSPathMakeRef((unsigned char*)path, fsr, NULL)) ) 3309 PyMac_Error(err); 3310 PyMem_Free(path); 3311 return !err; 3312 } 3313 /* XXXX Should try unicode here too */ 3314 3315 #ifndef __LP64__ 3316 /* Otherwise we try to go via an FSSpec */ 3317 if (FSSpec_Check(v)) { 3318 fss = ((FSSpecObject *)v)->ob_itself; 3319 if ((err=FSpMakeFSRef(&fss, fsr)) == 0) 3320 return 1; 3321 PyMac_Error(err); 3322 return 0; 3323 } 3324 #endif /* !__LP64__ */ 3325 3326 PyErr_SetString(PyExc_TypeError, "FSRef, FSSpec or pathname required"); 3327 return 0; 3328 } 3329 3330 #ifndef __LP64__ 3331 extern PyObject * 3332 PyMac_BuildFSSpec(FSSpec *spec) 3333 { 3334 return FSSpec_New(spec); 3335 } 3336 #endif /* !__LP64__ */ 3337 3338 extern PyObject * 3339 PyMac_BuildFSRef(FSRef *spec) 3340 { 3341 return FSRef_New(spec); 3342 } 3343 3344 3345 void init_File(void) 3346 { 3347 PyObject *m; 3348 PyObject *d; 3349 3350 3351 #ifndef __LP64__ 3352 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSSpec *, PyMac_BuildFSSpec); 3353 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSSpec, PyMac_GetFSSpec); 3354 #endif /* !__LP64__ */ 3355 3356 PyMac_INIT_TOOLBOX_OBJECT_NEW(FSRef *, PyMac_BuildFSRef); 3357 PyMac_INIT_TOOLBOX_OBJECT_CONVERT(FSRef, PyMac_GetFSRef); 3358 3359 3360 m = Py_InitModule("_File", File_methods); 3361 d = PyModule_GetDict(m); 3362 File_Error = PyMac_GetOSErrException(); 3363 if (File_Error == NULL || 3364 PyDict_SetItemString(d, "Error", File_Error) != 0) 3365 return; 3366 FSCatalogInfo_Type.ob_type = &PyType_Type; 3367 if (PyType_Ready(&FSCatalogInfo_Type) < 0) return; 3368 Py_INCREF(&FSCatalogInfo_Type); 3369 PyModule_AddObject(m, "FSCatalogInfo", (PyObject *)&FSCatalogInfo_Type); 3370 /* Backward-compatible name */ 3371 Py_INCREF(&FSCatalogInfo_Type); 3372 PyModule_AddObject(m, "FSCatalogInfoType", (PyObject *)&FSCatalogInfo_Type); 3373 3374 #ifndef __LP64__ 3375 FInfo_Type.ob_type = &PyType_Type; 3376 if (PyType_Ready(&FInfo_Type) < 0) return; 3377 Py_INCREF(&FInfo_Type); 3378 PyModule_AddObject(m, "FInfo", (PyObject *)&FInfo_Type); 3379 /* Backward-compatible name */ 3380 Py_INCREF(&FInfo_Type); 3381 PyModule_AddObject(m, "FInfoType", (PyObject *)&FInfo_Type); 3382 #endif /* !__LP64__ */ 3383 Alias_Type.ob_type = &PyType_Type; 3384 if (PyType_Ready(&Alias_Type) < 0) return; 3385 Py_INCREF(&Alias_Type); 3386 PyModule_AddObject(m, "Alias", (PyObject *)&Alias_Type); 3387 /* Backward-compatible name */ 3388 Py_INCREF(&Alias_Type); 3389 PyModule_AddObject(m, "AliasType", (PyObject *)&Alias_Type); 3390 3391 #ifndef __LP64__ 3392 FSSpec_Type.ob_type = &PyType_Type; 3393 if (PyType_Ready(&FSSpec_Type) < 0) return; 3394 Py_INCREF(&FSSpec_Type); 3395 PyModule_AddObject(m, "FSSpec", (PyObject *)&FSSpec_Type); 3396 /* Backward-compatible name */ 3397 Py_INCREF(&FSSpec_Type); 3398 PyModule_AddObject(m, "FSSpecType", (PyObject *)&FSSpec_Type); 3399 #endif /* !__LP64__ */ 3400 FSRef_Type.ob_type = &PyType_Type; 3401 if (PyType_Ready(&FSRef_Type) < 0) return; 3402 Py_INCREF(&FSRef_Type); 3403 PyModule_AddObject(m, "FSRef", (PyObject *)&FSRef_Type); 3404 /* Backward-compatible name */ 3405 Py_INCREF(&FSRef_Type); 3406 PyModule_AddObject(m, "FSRefType", (PyObject *)&FSRef_Type); 3407 } 3408 3409 /* ======================== End module _File ======================== */ 3410 3411
