diff --git a/Mac/Lib/Carbon/File.py b/Mac/Lib/Carbon/File.py new file mode 100644 index 00000000000..58c28574c74 --- /dev/null +++ b/Mac/Lib/Carbon/File.py @@ -0,0 +1 @@ +from _File import * diff --git a/Mac/Lib/Carbon/Files.py b/Mac/Lib/Carbon/Files.py new file mode 100644 index 00000000000..3e07ff677e9 --- /dev/null +++ b/Mac/Lib/Carbon/Files.py @@ -0,0 +1,340 @@ +# Generated from 'Files.h' + +def FOUR_CHAR_CODE(x): return x +true = True +false = False +fsCurPerm = 0x00 +fsRdPerm = 0x01 +fsWrPerm = 0x02 +fsRdWrPerm = 0x03 +fsRdWrShPerm = 0x04 +fsRdDenyPerm = 0x10 +fsWrDenyPerm = 0x20 +fsRtParID = 1 +fsRtDirID = 2 +fsAtMark = 0 +fsFromStart = 1 +fsFromLEOF = 2 +fsFromMark = 3 +pleaseCacheBit = 4 +pleaseCacheMask = 0x0010 +noCacheBit = 5 +noCacheMask = 0x0020 +rdVerifyBit = 6 +rdVerifyMask = 0x0040 +rdVerify = 64 +forceReadBit = 6 +forceReadMask = 0x0040 +newLineBit = 7 +newLineMask = 0x0080 +newLineCharMask = 0xFF00 +fsSBPartialName = 1 +fsSBFullName = 2 +fsSBFlAttrib = 4 +fsSBFlFndrInfo = 8 +fsSBFlLgLen = 32 +fsSBFlPyLen = 64 +fsSBFlRLgLen = 128 +fsSBFlRPyLen = 256 +fsSBFlCrDat = 512 +fsSBFlMdDat = 1024 +fsSBFlBkDat = 2048 +fsSBFlXFndrInfo = 4096 +fsSBFlParID = 8192 +fsSBNegate = 16384 +fsSBDrUsrWds = 8 +fsSBDrNmFls = 16 +fsSBDrCrDat = 512 +fsSBDrMdDat = 1024 +fsSBDrBkDat = 2048 +fsSBDrFndrInfo = 4096 +fsSBDrParID = 8192 +fsSBPartialNameBit = 0 +fsSBFullNameBit = 1 +fsSBFlAttribBit = 2 +fsSBFlFndrInfoBit = 3 +fsSBFlLgLenBit = 5 +fsSBFlPyLenBit = 6 +fsSBFlRLgLenBit = 7 +fsSBFlRPyLenBit = 8 +fsSBFlCrDatBit = 9 +fsSBFlMdDatBit = 10 +fsSBFlBkDatBit = 11 +fsSBFlXFndrInfoBit = 12 +fsSBFlParIDBit = 13 +fsSBNegateBit = 14 +fsSBDrUsrWdsBit = 3 +fsSBDrNmFlsBit = 4 +fsSBDrCrDatBit = 9 +fsSBDrMdDatBit = 10 +fsSBDrBkDatBit = 11 +fsSBDrFndrInfoBit = 12 +fsSBDrParIDBit = 13 +bLimitFCBs = 31 +bLocalWList = 30 +bNoMiniFndr = 29 +bNoVNEdit = 28 +bNoLclSync = 27 +bTrshOffLine = 26 +bNoSwitchTo = 25 +bNoDeskItems = 20 +bNoBootBlks = 19 +bAccessCntl = 18 +bNoSysDir = 17 +bHasExtFSVol = 16 +bHasOpenDeny = 15 +bHasCopyFile = 14 +bHasMoveRename = 13 +bHasDesktopMgr = 12 +bHasShortName = 11 +bHasFolderLock = 10 +bHasPersonalAccessPrivileges = 9 +bHasUserGroupList = 8 +bHasCatSearch = 7 +bHasFileIDs = 6 +bHasBTreeMgr = 5 +bHasBlankAccessPrivileges = 4 +bSupportsAsyncRequests = 3 +bSupportsTrashVolumeCache = 2 +bIsEjectable = 0 +bSupportsHFSPlusAPIs = 1 +bSupportsFSCatalogSearch = 2 +bSupportsFSExchangeObjects = 3 +bSupports2TBFiles = 4 +bSupportsLongNames = 5 +bSupportsMultiScriptNames = 6 +bSupportsNamedForks = 7 +bSupportsSubtreeIterators = 8 +bL2PCanMapFileBlocks = 9 +bParentModDateChanges = 10 +bAncestorModDateChanges = 11 +bSupportsSymbolicLinks = 13 +bIsAutoMounted = 14 +bAllowCDiDataHandler = 17 +kLargeIcon = 1 +kLarge4BitIcon = 2 +kLarge8BitIcon = 3 +kSmallIcon = 4 +kSmall4BitIcon = 5 +kSmall8BitIcon = 6 +kicnsIconFamily = 239 +kLargeIconSize = 256 +kLarge4BitIconSize = 512 +kLarge8BitIconSize = 1024 +kSmallIconSize = 64 +kSmall4BitIconSize = 128 +kSmall8BitIconSize = 256 +kWidePosOffsetBit = 8 +kUseWidePositioning = (1 << kWidePosOffsetBit) +kMaximumBlocksIn4GB = 0x007FFFFF +fsUnixPriv = 1 +kNoUserAuthentication = 1 +kPassword = 2 +kEncryptPassword = 3 +kTwoWayEncryptPassword = 6 +kOwnerID2Name = 1 +kGroupID2Name = 2 +kOwnerName2ID = 3 +kGroupName2ID = 4 +kReturnNextUser = 1 +kReturnNextGroup = 2 +kReturnNextUG = 3 +kVCBFlagsIdleFlushBit = 3 +kVCBFlagsIdleFlushMask = 0x0008 +kVCBFlagsHFSPlusAPIsBit = 4 +kVCBFlagsHFSPlusAPIsMask = 0x0010 +kVCBFlagsHardwareGoneBit = 5 +kVCBFlagsHardwareGoneMask = 0x0020 +kVCBFlagsVolumeDirtyBit = 15 +kVCBFlagsVolumeDirtyMask = 0x8000 +kioVAtrbDefaultVolumeBit = 5 +kioVAtrbDefaultVolumeMask = 0x0020 +kioVAtrbFilesOpenBit = 6 +kioVAtrbFilesOpenMask = 0x0040 +kioVAtrbHardwareLockedBit = 7 +kioVAtrbHardwareLockedMask = 0x0080 +kioVAtrbSoftwareLockedBit = 15 +kioVAtrbSoftwareLockedMask = 0x8000 +kioFlAttribLockedBit = 0 +kioFlAttribLockedMask = 0x01 +kioFlAttribResOpenBit = 2 +kioFlAttribResOpenMask = 0x04 +kioFlAttribDataOpenBit = 3 +kioFlAttribDataOpenMask = 0x08 +kioFlAttribDirBit = 4 +kioFlAttribDirMask = 0x10 +ioDirFlg = 4 +ioDirMask = 0x10 +kioFlAttribCopyProtBit = 6 +kioFlAttribCopyProtMask = 0x40 +kioFlAttribFileOpenBit = 7 +kioFlAttribFileOpenMask = 0x80 +kioFlAttribInSharedBit = 2 +kioFlAttribInSharedMask = 0x04 +kioFlAttribMountedBit = 3 +kioFlAttribMountedMask = 0x08 +kioFlAttribSharePointBit = 5 +kioFlAttribSharePointMask = 0x20 +kioFCBWriteBit = 8 +kioFCBWriteMask = 0x0100 +kioFCBResourceBit = 9 +kioFCBResourceMask = 0x0200 +kioFCBWriteLockedBit = 10 +kioFCBWriteLockedMask = 0x0400 +kioFCBLargeFileBit = 11 +kioFCBLargeFileMask = 0x0800 +kioFCBSharedWriteBit = 12 +kioFCBSharedWriteMask = 0x1000 +kioFCBFileLockedBit = 13 +kioFCBFileLockedMask = 0x2000 +kioFCBOwnClumpBit = 14 +kioFCBOwnClumpMask = 0x4000 +kioFCBModifiedBit = 15 +kioFCBModifiedMask = 0x8000 +kioACUserNoSeeFolderBit = 0 +kioACUserNoSeeFolderMask = 0x01 +kioACUserNoSeeFilesBit = 1 +kioACUserNoSeeFilesMask = 0x02 +kioACUserNoMakeChangesBit = 2 +kioACUserNoMakeChangesMask = 0x04 +kioACUserNotOwnerBit = 7 +kioACUserNotOwnerMask = 0x80 +kioACAccessOwnerBit = 31 +# kioACAccessOwnerMask = (long)0x80000000 +kioACAccessBlankAccessBit = 28 +kioACAccessBlankAccessMask = 0x10000000 +kioACAccessUserWriteBit = 26 +kioACAccessUserWriteMask = 0x04000000 +kioACAccessUserReadBit = 25 +kioACAccessUserReadMask = 0x02000000 +kioACAccessUserSearchBit = 24 +kioACAccessUserSearchMask = 0x01000000 +kioACAccessEveryoneWriteBit = 18 +kioACAccessEveryoneWriteMask = 0x00040000 +kioACAccessEveryoneReadBit = 17 +kioACAccessEveryoneReadMask = 0x00020000 +kioACAccessEveryoneSearchBit = 16 +kioACAccessEveryoneSearchMask = 0x00010000 +kioACAccessGroupWriteBit = 10 +kioACAccessGroupWriteMask = 0x00000400 +kioACAccessGroupReadBit = 9 +kioACAccessGroupReadMask = 0x00000200 +kioACAccessGroupSearchBit = 8 +kioACAccessGroupSearchMask = 0x00000100 +kioACAccessOwnerWriteBit = 2 +kioACAccessOwnerWriteMask = 0x00000004 +kioACAccessOwnerReadBit = 1 +kioACAccessOwnerReadMask = 0x00000002 +kioACAccessOwnerSearchBit = 0 +kioACAccessOwnerSearchMask = 0x00000001 +kfullPrivileges = 0x00070007 +kownerPrivileges = 0x00000007 +knoUser = 0 +kadministratorUser = 1 +knoGroup = 0 +AppleShareMediaType = FOUR_CHAR_CODE('afpm') +volMountNoLoginMsgFlagBit = 0 +volMountNoLoginMsgFlagMask = 0x0001 +volMountExtendedFlagsBit = 7 +volMountExtendedFlagsMask = 0x0080 +volMountInteractBit = 15 +volMountInteractMask = 0x8000 +volMountChangedBit = 14 +volMountChangedMask = 0x4000 +volMountFSReservedMask = 0x00FF +volMountSysReservedMask = 0xFF00 +kAFPExtendedFlagsAlternateAddressMask = 1 +kAFPTagTypeIP = 0x01 +kAFPTagTypeIPPort = 0x02 +kAFPTagTypeDDP = 0x03 +kAFPTagTypeDNS = 0x04 +kAFPTagLengthIP = 0x06 +kAFPTagLengthIPPort = 0x08 +kAFPTagLengthDDP = 0x06 +kFSInvalidVolumeRefNum = 0 +kFSCatInfoNone = 0x00000000 +kFSCatInfoTextEncoding = 0x00000001 +kFSCatInfoNodeFlags = 0x00000002 +kFSCatInfoVolume = 0x00000004 +kFSCatInfoParentDirID = 0x00000008 +kFSCatInfoNodeID = 0x00000010 +kFSCatInfoCreateDate = 0x00000020 +kFSCatInfoContentMod = 0x00000040 +kFSCatInfoAttrMod = 0x00000080 +kFSCatInfoAccessDate = 0x00000100 +kFSCatInfoBackupDate = 0x00000200 +kFSCatInfoPermissions = 0x00000400 +kFSCatInfoFinderInfo = 0x00000800 +kFSCatInfoFinderXInfo = 0x00001000 +kFSCatInfoValence = 0x00002000 +kFSCatInfoDataSizes = 0x00004000 +kFSCatInfoRsrcSizes = 0x00008000 +kFSCatInfoSharingFlags = 0x00010000 +kFSCatInfoUserPrivs = 0x00020000 +kFSCatInfoAllDates = 0x000003E0 +kFSCatInfoGettableInfo = 0x0003FFFF +kFSCatInfoSettableInfo = 0x00001FE3 +# kFSCatInfoReserved = (long)0xFFFC0000 +kFSNodeLockedBit = 0 +kFSNodeLockedMask = 0x0001 +kFSNodeResOpenBit = 2 +kFSNodeResOpenMask = 0x0004 +kFSNodeDataOpenBit = 3 +kFSNodeDataOpenMask = 0x0008 +kFSNodeIsDirectoryBit = 4 +kFSNodeIsDirectoryMask = 0x0010 +kFSNodeCopyProtectBit = 6 +kFSNodeCopyProtectMask = 0x0040 +kFSNodeForkOpenBit = 7 +kFSNodeForkOpenMask = 0x0080 +kFSNodeInSharedBit = 2 +kFSNodeInSharedMask = 0x0004 +kFSNodeIsMountedBit = 3 +kFSNodeIsMountedMask = 0x0008 +kFSNodeIsSharePointBit = 5 +kFSNodeIsSharePointMask = 0x0020 +kFSIterateFlat = 0 +kFSIterateSubtree = 1 +kFSIterateDelete = 2 +# kFSIterateReserved = (long)0xFFFFFFFC +fsSBNodeID = 0x00008000 +fsSBAttributeModDate = 0x00010000 +fsSBAccessDate = 0x00020000 +fsSBPermissions = 0x00040000 +fsSBNodeIDBit = 15 +fsSBAttributeModDateBit = 16 +fsSBAccessDateBit = 17 +fsSBPermissionsBit = 18 +kFSAllocDefaultFlags = 0x0000 +kFSAllocAllOrNothingMask = 0x0001 +kFSAllocContiguousMask = 0x0002 +kFSAllocNoRoundUpMask = 0x0004 +kFSAllocReservedMask = 0xFFF8 +kFSVolInfoNone = 0x0000 +kFSVolInfoCreateDate = 0x0001 +kFSVolInfoModDate = 0x0002 +kFSVolInfoBackupDate = 0x0004 +kFSVolInfoCheckedDate = 0x0008 +kFSVolInfoFileCount = 0x0010 +kFSVolInfoDirCount = 0x0020 +kFSVolInfoSizes = 0x0040 +kFSVolInfoBlocks = 0x0080 +kFSVolInfoNextAlloc = 0x0100 +kFSVolInfoRsrcClump = 0x0200 +kFSVolInfoDataClump = 0x0400 +kFSVolInfoNextID = 0x0800 +kFSVolInfoFinderInfo = 0x1000 +kFSVolInfoFlags = 0x2000 +kFSVolInfoFSInfo = 0x4000 +kFSVolInfoDriveInfo = 0x8000 +kFSVolInfoGettableInfo = 0xFFFF +kFSVolInfoSettableInfo = 0x3004 +kFSVolFlagDefaultVolumeBit = 5 +kFSVolFlagDefaultVolumeMask = 0x0020 +kFSVolFlagFilesOpenBit = 6 +kFSVolFlagFilesOpenMask = 0x0040 +kFSVolFlagHardwareLockedBit = 7 +kFSVolFlagHardwareLockedMask = 0x0080 +kFSVolFlagSoftwareLockedBit = 15 +kFSVolFlagSoftwareLockedMask = 0x8000 +kFNDirectoryModifiedMessage = 1 diff --git a/Mac/Lib/Carbon/Folder.py b/Mac/Lib/Carbon/Folder.py new file mode 100644 index 00000000000..a4e49028924 --- /dev/null +++ b/Mac/Lib/Carbon/Folder.py @@ -0,0 +1 @@ +from _Folder import * diff --git a/Mac/Lib/Carbon/Folders.py b/Mac/Lib/Carbon/Folders.py new file mode 100644 index 00000000000..7a69ca41ad7 --- /dev/null +++ b/Mac/Lib/Carbon/Folders.py @@ -0,0 +1,185 @@ +# Generated from 'Folders.h' + +def FOUR_CHAR_CODE(x): return x +true = True +false = False +kOnSystemDisk = -32768L +kOnAppropriateDisk = -32767 +kSystemDomain = -32766 +kLocalDomain = -32765 +kNetworkDomain = -32764 +kUserDomain = -32763 +kClassicDomain = -32762 +kCreateFolder = true +kDontCreateFolder = false +kSystemFolderType = FOUR_CHAR_CODE('macs') +kDesktopFolderType = FOUR_CHAR_CODE('desk') +kSystemDesktopFolderType = FOUR_CHAR_CODE('sdsk') +kTrashFolderType = FOUR_CHAR_CODE('trsh') +kSystemTrashFolderType = FOUR_CHAR_CODE('strs') +kWhereToEmptyTrashFolderType = FOUR_CHAR_CODE('empt') +kPrintMonitorDocsFolderType = FOUR_CHAR_CODE('prnt') +kStartupFolderType = FOUR_CHAR_CODE('strt') +kShutdownFolderType = FOUR_CHAR_CODE('shdf') +kAppleMenuFolderType = FOUR_CHAR_CODE('amnu') +kControlPanelFolderType = FOUR_CHAR_CODE('ctrl') +kSystemControlPanelFolderType = FOUR_CHAR_CODE('sctl') +kExtensionFolderType = FOUR_CHAR_CODE('extn') +kFontsFolderType = FOUR_CHAR_CODE('font') +kPreferencesFolderType = FOUR_CHAR_CODE('pref') +kSystemPreferencesFolderType = FOUR_CHAR_CODE('sprf') +kTemporaryFolderType = FOUR_CHAR_CODE('temp') +kExtensionDisabledFolderType = FOUR_CHAR_CODE('extD') +kControlPanelDisabledFolderType = FOUR_CHAR_CODE('ctrD') +kSystemExtensionDisabledFolderType = FOUR_CHAR_CODE('macD') +kStartupItemsDisabledFolderType = FOUR_CHAR_CODE('strD') +kShutdownItemsDisabledFolderType = FOUR_CHAR_CODE('shdD') +kApplicationsFolderType = FOUR_CHAR_CODE('apps') +kDocumentsFolderType = FOUR_CHAR_CODE('docs') +kVolumeRootFolderType = FOUR_CHAR_CODE('root') +kChewableItemsFolderType = FOUR_CHAR_CODE('flnt') +kApplicationSupportFolderType = FOUR_CHAR_CODE('asup') +kTextEncodingsFolderType = FOUR_CHAR_CODE('\xc4tex') +kStationeryFolderType = FOUR_CHAR_CODE('odst') +kOpenDocFolderType = FOUR_CHAR_CODE('odod') +kOpenDocShellPlugInsFolderType = FOUR_CHAR_CODE('odsp') +kEditorsFolderType = FOUR_CHAR_CODE('oded') +kOpenDocEditorsFolderType = FOUR_CHAR_CODE('\xc4odf') +kOpenDocLibrariesFolderType = FOUR_CHAR_CODE('odlb') +kGenEditorsFolderType = FOUR_CHAR_CODE('\xc4edi') +kHelpFolderType = FOUR_CHAR_CODE('\xc4hlp') +kInternetPlugInFolderType = FOUR_CHAR_CODE('\xc4net') +kModemScriptsFolderType = FOUR_CHAR_CODE('\xc4mod') +kPrinterDescriptionFolderType = FOUR_CHAR_CODE('ppdf') +kPrinterDriverFolderType = FOUR_CHAR_CODE('\xc4prd') +kScriptingAdditionsFolderType = FOUR_CHAR_CODE('\xc4scr') +kSharedLibrariesFolderType = FOUR_CHAR_CODE('\xc4lib') +kVoicesFolderType = FOUR_CHAR_CODE('fvoc') +kControlStripModulesFolderType = FOUR_CHAR_CODE('sdev') +kAssistantsFolderType = FOUR_CHAR_CODE('ast\xc4') +kUtilitiesFolderType = FOUR_CHAR_CODE('uti\xc4') +kAppleExtrasFolderType = FOUR_CHAR_CODE('aex\xc4') +kContextualMenuItemsFolderType = FOUR_CHAR_CODE('cmnu') +kMacOSReadMesFolderType = FOUR_CHAR_CODE('mor\xc4') +kALMModulesFolderType = FOUR_CHAR_CODE('walk') +kALMPreferencesFolderType = FOUR_CHAR_CODE('trip') +kALMLocationsFolderType = FOUR_CHAR_CODE('fall') +kColorSyncProfilesFolderType = FOUR_CHAR_CODE('prof') +kThemesFolderType = FOUR_CHAR_CODE('thme') +kFavoritesFolderType = FOUR_CHAR_CODE('favs') +kInternetFolderType = FOUR_CHAR_CODE('int\xc4') +kAppearanceFolderType = FOUR_CHAR_CODE('appr') +kSoundSetsFolderType = FOUR_CHAR_CODE('snds') +kDesktopPicturesFolderType = FOUR_CHAR_CODE('dtp\xc4') +kInternetSearchSitesFolderType = FOUR_CHAR_CODE('issf') +kFindSupportFolderType = FOUR_CHAR_CODE('fnds') +kFindByContentFolderType = FOUR_CHAR_CODE('fbcf') +kInstallerLogsFolderType = FOUR_CHAR_CODE('ilgf') +kScriptsFolderType = FOUR_CHAR_CODE('scr\xc4') +kFolderActionsFolderType = FOUR_CHAR_CODE('fasf') +kLauncherItemsFolderType = FOUR_CHAR_CODE('laun') +kRecentApplicationsFolderType = FOUR_CHAR_CODE('rapp') +kRecentDocumentsFolderType = FOUR_CHAR_CODE('rdoc') +kRecentServersFolderType = FOUR_CHAR_CODE('rsvr') +kSpeakableItemsFolderType = FOUR_CHAR_CODE('spki') +kKeychainFolderType = FOUR_CHAR_CODE('kchn') +kQuickTimeExtensionsFolderType = FOUR_CHAR_CODE('qtex') +kDisplayExtensionsFolderType = FOUR_CHAR_CODE('dspl') +kMultiprocessingFolderType = FOUR_CHAR_CODE('mpxf') +kPrintingPlugInsFolderType = FOUR_CHAR_CODE('pplg') +kDomainTopLevelFolderType = FOUR_CHAR_CODE('dtop') +kDomainLibraryFolderType = FOUR_CHAR_CODE('dlib') +kColorSyncFolderType = FOUR_CHAR_CODE('sync') +kColorSyncCMMFolderType = FOUR_CHAR_CODE('ccmm') +kColorSyncScriptingFolderType = FOUR_CHAR_CODE('cscr') +kPrintersFolderType = FOUR_CHAR_CODE('impr') +kSpeechFolderType = FOUR_CHAR_CODE('spch') +kCarbonLibraryFolderType = FOUR_CHAR_CODE('carb') +kDocumentationFolderType = FOUR_CHAR_CODE('info') +kDeveloperDocsFolderType = FOUR_CHAR_CODE('ddoc') +kDeveloperHelpFolderType = FOUR_CHAR_CODE('devh') +kISSDownloadsFolderType = FOUR_CHAR_CODE('issd') +kUserSpecificTmpFolderType = FOUR_CHAR_CODE('utmp') +kCachedDataFolderType = FOUR_CHAR_CODE('cach') +kFrameworksFolderType = FOUR_CHAR_CODE('fram') +kPrivateFrameworksFolderType = FOUR_CHAR_CODE('pfrm') +kClassicDesktopFolderType = FOUR_CHAR_CODE('sdsk') +kDeveloperFolderType = FOUR_CHAR_CODE('devf') +kSystemSoundsFolderType = FOUR_CHAR_CODE('ssnd') +kComponentsFolderType = FOUR_CHAR_CODE('cmpd') +kQuickTimeComponentsFolderType = FOUR_CHAR_CODE('wcmp') +kCoreServicesFolderType = FOUR_CHAR_CODE('csrv') +kPictureDocumentsFolderType = FOUR_CHAR_CODE('pdoc') +kMovieDocumentsFolderType = FOUR_CHAR_CODE('mdoc') +kMusicDocumentsFolderType = FOUR_CHAR_CODE('\xb5doc') +kInternetSitesFolderType = FOUR_CHAR_CODE('site') +kPublicFolderType = FOUR_CHAR_CODE('pubb') +kAudioSupportFolderType = FOUR_CHAR_CODE('adio') +kAudioSoundsFolderType = FOUR_CHAR_CODE('asnd') +kAudioSoundBanksFolderType = FOUR_CHAR_CODE('bank') +kAudioAlertSoundsFolderType = FOUR_CHAR_CODE('alrt') +kAudioPlugInsFolderType = FOUR_CHAR_CODE('aplg') +kAudioComponentsFolderType = FOUR_CHAR_CODE('acmp') +kKernelExtensionsFolderType = FOUR_CHAR_CODE('kext') +kDirectoryServicesFolderType = FOUR_CHAR_CODE('dsrv') +kDirectoryServicesPlugInsFolderType = FOUR_CHAR_CODE('dplg') +kLocalesFolderType = FOUR_CHAR_CODE('\xc4loc') +kFindByContentPluginsFolderType = FOUR_CHAR_CODE('fbcp') +kUsersFolderType = FOUR_CHAR_CODE('usrs') +kCurrentUserFolderType = FOUR_CHAR_CODE('cusr') +kCurrentUserRemoteFolderLocation = FOUR_CHAR_CODE('rusf') +kCurrentUserRemoteFolderType = FOUR_CHAR_CODE('rusr') +kSharedUserDataFolderType = FOUR_CHAR_CODE('sdat') +kVolumeSettingsFolderType = FOUR_CHAR_CODE('vsfd') +kAppleshareAutomountServerAliasesFolderType = FOUR_CHAR_CODE('srv\xc4') +kPreMacOS91ApplicationsFolderType = FOUR_CHAR_CODE('\x8cpps') +kPreMacOS91InstallerLogsFolderType = FOUR_CHAR_CODE('\x94lgf') +kPreMacOS91AssistantsFolderType = FOUR_CHAR_CODE('\x8cst\xc4') +kPreMacOS91UtilitiesFolderType = FOUR_CHAR_CODE('\x9fti\xc4') +kPreMacOS91AppleExtrasFolderType = FOUR_CHAR_CODE('\x8cex\xc4') +kPreMacOS91MacOSReadMesFolderType = FOUR_CHAR_CODE('\xb5or\xc4') +kPreMacOS91InternetFolderType = FOUR_CHAR_CODE('\x94nt\xc4') +kPreMacOS91AutomountedServersFolderType = FOUR_CHAR_CODE('\xa7rv\xc4') +kPreMacOS91StationeryFolderType = FOUR_CHAR_CODE('\xbfdst') +kCreateFolderAtBoot = 0x00000002 +kCreateFolderAtBootBit = 1 +kFolderCreatedInvisible = 0x00000004 +kFolderCreatedInvisibleBit = 2 +kFolderCreatedNameLocked = 0x00000008 +kFolderCreatedNameLockedBit = 3 +kFolderCreatedAdminPrivs = 0x00000010 +kFolderCreatedAdminPrivsBit = 4 +kFolderInUserFolder = 0x00000020 +kFolderInUserFolderBit = 5 +kFolderTrackedByAlias = 0x00000040 +kFolderTrackedByAliasBit = 6 +kFolderInRemoteUserFolderIfAvailable = 0x00000080 +kFolderInRemoteUserFolderIfAvailableBit = 7 +kFolderNeverMatchedInIdentifyFolder = 0x00000100 +kFolderNeverMatchedInIdentifyFolderBit = 8 +kFolderMustStayOnSameVolume = 0x00000200 +kFolderMustStayOnSameVolumeBit = 9 +kFolderManagerFolderInMacOS9FolderIfMacOSXIsInstalledMask = 0x00000400 +kFolderManagerFolderInMacOS9FolderIfMacOSXIsInstalledBit = 10 +kFolderInLocalOrRemoteUserFolder = kFolderInUserFolder | kFolderInRemoteUserFolderIfAvailable +kRelativeFolder = FOUR_CHAR_CODE('relf') +kSpecialFolder = FOUR_CHAR_CODE('spcf') +kBlessedFolder = FOUR_CHAR_CODE('blsf') +kRootFolder = FOUR_CHAR_CODE('rotf') +kCurrentUserFolderLocation = FOUR_CHAR_CODE('cusf') +kFindFolderRedirectionFlagUseDistinctUserFoldersBit = 0 +kFindFolderRedirectionFlagUseGivenVRefAndDirIDAsUserFolderBit = 1 +kFindFolderRedirectionFlagsUseGivenVRefNumAndDirIDAsRemoteUserFolderBit = 2 +kFolderManagerUserRedirectionGlobalsCurrentVersion = 1 +kFindFolderExtendedFlagsDoNotFollowAliasesBit = 0 +kFindFolderExtendedFlagsDoNotUseUserFolderBit = 1 +kFindFolderExtendedFlagsUseOtherUserRecord = 0x01000000 +kFolderManagerNotificationMessageUserLogIn = FOUR_CHAR_CODE('log+') +kFolderManagerNotificationMessagePreUserLogIn = FOUR_CHAR_CODE('logj') +kFolderManagerNotificationMessageUserLogOut = FOUR_CHAR_CODE('log-') +kFolderManagerNotificationMessagePostUserLogOut = FOUR_CHAR_CODE('logp') +kFolderManagerNotificationDiscardCachedData = FOUR_CHAR_CODE('dche') +kFolderManagerNotificationMessageLoginStartup = FOUR_CHAR_CODE('stup') +kDoNotRemoveWhenCurrentApplicationQuitsBit = 0 +kDoNotRemoveWheCurrentApplicationQuitsBit = kDoNotRemoveWhenCurrentApplicationQuitsBit +kStopIfAnyNotificationProcReturnsErrorBit = 31 diff --git a/Mac/Modules/file/_Filemodule.c b/Mac/Modules/file/_Filemodule.c new file mode 100644 index 00000000000..6f7ef51fd57 --- /dev/null +++ b/Mac/Modules/file/_Filemodule.c @@ -0,0 +1,1446 @@ + +/* ========================== Module _File ========================== */ + +#include "Python.h" + + + +#ifdef _WIN32 +#include "pywintoolbox.h" +#else +#include "macglue.h" +#include "pymactoolbox.h" +#endif + +/* Macro to test whether a weak-loaded CFM function exists */ +#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ + PyErr_SetString(PyExc_NotImplementedError, \ + "Not available in this shared library/OS version"); \ + return NULL; \ + }} while(0) + + +#ifdef WITHOUT_FRAMEWORKS +#include +#else +#include +#endif + +/* +** Parse/generate objsect +*/ +static PyObject * +PyMac_BuildHFSUniStr255(HFSUniStr255 *itself) +{ + + return Py_BuildValue("u#", itself->unicode, itself->length); +} + +#if 0 +static int +PyMac_GetHFSUniStr255(PyObject *v, HFSUniStr255 *itself) +{ + return PyArg_ParseTuple(v, "O&O&O&O&O&", + PyMac_GetFixed, &itself->ascent, + PyMac_GetFixed, &itself->descent, + PyMac_GetFixed, &itself->leading, + PyMac_GetFixed, &itself->widMax, + ResObj_Convert, &itself->wTabHandle); +} +#endif + +/* +** Parse/generate objsect +*/ +static PyObject * +PyMac_BuildFInfo(FInfo *itself) +{ + + return Py_BuildValue("O&O&HO&h", + PyMac_BuildOSType, itself->fdType, + PyMac_BuildOSType, itself->fdCreator, + itself->fdFlags, + PyMac_BuildPoint, &itself->fdLocation, + itself->fdFldr); +} + +static int +PyMac_GetFInfo(PyObject *v, FInfo *itself) +{ + return PyArg_ParseTuple(v, "O&O&HO&h", + PyMac_GetOSType, &itself->fdType, + PyMac_GetOSType, &itself->fdCreator, + &itself->fdFlags, + PyMac_GetPoint, &itself->fdLocation, + &itself->fdFldr); +} + + +static PyObject *File_Error; + +static PyObject *File_UnmountVol(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Str63 volName; + short vRefNum; + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetStr255, volName, + &vRefNum)) + return NULL; + _err = UnmountVol(volName, + vRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FlushVol(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Str63 volName; + short vRefNum; + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetStr255, volName, + &vRefNum)) + return NULL; + _err = FlushVol(volName, + vRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_HSetVol(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + Str63 volName; + short vRefNum; + long dirID; + if (!PyArg_ParseTuple(_args, "O&hl", + PyMac_GetStr255, volName, + &vRefNum, + &dirID)) + return NULL; + _err = HSetVol(volName, + vRefNum, + dirID); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSClose(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = FSClose(refNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_Allocate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + long count; + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = Allocate(refNum, + &count); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + count); + return _res; +} + +static PyObject *File_GetEOF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + long logEOF; + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = GetEOF(refNum, + &logEOF); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + logEOF); + return _res; +} + +static PyObject *File_SetEOF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + long logEOF; + if (!PyArg_ParseTuple(_args, "hl", + &refNum, + &logEOF)) + return NULL; + _err = SetEOF(refNum, + logEOF); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_GetFPos(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + long filePos; + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = GetFPos(refNum, + &filePos); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + filePos); + return _res; +} + +static PyObject *File_SetFPos(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + short posMode; + long posOff; + if (!PyArg_ParseTuple(_args, "hhl", + &refNum, + &posMode, + &posOff)) + return NULL; + _err = SetFPos(refNum, + posMode, + posOff); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_GetVRefNum(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short fileRefNum; + short vRefNum; + if (!PyArg_ParseTuple(_args, "h", + &fileRefNum)) + return NULL; + _err = GetVRefNum(fileRefNum, + &vRefNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + vRefNum); + return _res; +} + +static PyObject *File_HGetVol(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + StringPtr volName; + short vRefNum; + long dirID; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetStr255, &volName)) + return NULL; + _err = HGetVol(volName, + &vRefNum, + &dirID); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("hl", + vRefNum, + dirID); + return _res; +} + +static PyObject *File_HOpen(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + SInt8 permission; + short refNum; + if (!PyArg_ParseTuple(_args, "hlO&b", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + &permission)) + return NULL; + _err = HOpen(vRefNum, + dirID, + fileName, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *File_HOpenDF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + SInt8 permission; + short refNum; + if (!PyArg_ParseTuple(_args, "hlO&b", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + &permission)) + return NULL; + _err = HOpenDF(vRefNum, + dirID, + fileName, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *File_HOpenRF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + SInt8 permission; + short refNum; + if (!PyArg_ParseTuple(_args, "hlO&b", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + &permission)) + return NULL; + _err = HOpenRF(vRefNum, + dirID, + fileName, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *File_AllocContig(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short refNum; + long count; + if (!PyArg_ParseTuple(_args, "h", + &refNum)) + return NULL; + _err = AllocContig(refNum, + &count); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + count); + return _res; +} + +static PyObject *File_HCreate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + OSType creator; + OSType fileType; + if (!PyArg_ParseTuple(_args, "hlO&O&O&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + PyMac_GetOSType, &creator, + PyMac_GetOSType, &fileType)) + return NULL; + _err = HCreate(vRefNum, + dirID, + fileName, + creator, + fileType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_DirCreate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long parentDirID; + Str255 directoryName; + long createdDirID; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &parentDirID, + PyMac_GetStr255, directoryName)) + return NULL; + _err = DirCreate(vRefNum, + parentDirID, + directoryName, + &createdDirID); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + createdDirID); + return _res; +} + +static PyObject *File_HDelete(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + _err = HDelete(vRefNum, + dirID, + fileName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_HGetFInfo(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + FInfo fndrInfo; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + _err = HGetFInfo(vRefNum, + dirID, + fileName, + &fndrInfo); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFInfo, &fndrInfo); + return _res; +} + +static PyObject *File_HSetFInfo(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + FInfo fndrInfo; + if (!PyArg_ParseTuple(_args, "hlO&O&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName, + PyMac_GetFInfo, &fndrInfo)) + return NULL; + _err = HSetFInfo(vRefNum, + dirID, + fileName, + &fndrInfo); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_HSetFLock(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + _err = HSetFLock(vRefNum, + dirID, + fileName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_HRstFLock(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + _err = HRstFLock(vRefNum, + dirID, + fileName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_HRename(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 oldName; + Str255 newName; + if (!PyArg_ParseTuple(_args, "hlO&O&", + &vRefNum, + &dirID, + PyMac_GetStr255, oldName, + PyMac_GetStr255, newName)) + return NULL; + _err = HRename(vRefNum, + dirID, + oldName, + newName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_CatMove(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 oldName; + long newDirID; + Str255 newName; + if (!PyArg_ParseTuple(_args, "hlO&lO&", + &vRefNum, + &dirID, + PyMac_GetStr255, oldName, + &newDirID, + PyMac_GetStr255, newName)) + return NULL; + _err = CatMove(vRefNum, + dirID, + oldName, + newDirID, + newName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSMakeFSSpec(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + Str255 fileName; + FSSpec spec; + if (!PyArg_ParseTuple(_args, "hlO&", + &vRefNum, + &dirID, + PyMac_GetStr255, fileName)) + return NULL; + _err = FSMakeFSSpec(vRefNum, + dirID, + fileName, + &spec); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSSpec, &spec); + return _res; +} + +static PyObject *File_FSpOpenDF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + SInt8 permission; + short refNum; + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSSpec, &spec, + &permission)) + return NULL; + _err = FSpOpenDF(&spec, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *File_FSpOpenRF(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + SInt8 permission; + short refNum; + if (!PyArg_ParseTuple(_args, "O&b", + PyMac_GetFSSpec, &spec, + &permission)) + return NULL; + _err = FSpOpenRF(&spec, + permission, + &refNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + refNum); + return _res; +} + +static PyObject *File_FSpCreate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + OSType creator; + OSType fileType; + ScriptCode scriptTag; + if (!PyArg_ParseTuple(_args, "O&O&O&h", + PyMac_GetFSSpec, &spec, + PyMac_GetOSType, &creator, + PyMac_GetOSType, &fileType, + &scriptTag)) + return NULL; + _err = FSpCreate(&spec, + creator, + fileType, + scriptTag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpDirCreate(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + ScriptCode scriptTag; + long createdDirID; + if (!PyArg_ParseTuple(_args, "O&h", + PyMac_GetFSSpec, &spec, + &scriptTag)) + return NULL; + _err = FSpDirCreate(&spec, + scriptTag, + &createdDirID); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("l", + createdDirID); + return _res; +} + +static PyObject *File_FSpDelete(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &spec)) + return NULL; + _err = FSpDelete(&spec); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpGetFInfo(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + FInfo fndrInfo; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &spec)) + return NULL; + _err = FSpGetFInfo(&spec, + &fndrInfo); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFInfo, &fndrInfo); + return _res; +} + +static PyObject *File_FSpSetFInfo(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + FInfo fndrInfo; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &spec, + PyMac_GetFInfo, &fndrInfo)) + return NULL; + _err = FSpSetFInfo(&spec, + &fndrInfo); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpSetFLock(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &spec)) + return NULL; + _err = FSpSetFLock(&spec); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpRstFLock(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &spec)) + return NULL; + _err = FSpRstFLock(&spec); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpRename(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec spec; + Str255 newName; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &spec, + PyMac_GetStr255, newName)) + return NULL; + _err = FSpRename(&spec, + newName); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpCatMove(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec source; + FSSpec dest; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &source, + PyMac_GetFSSpec, &dest)) + return NULL; + _err = FSpCatMove(&source, + &dest); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpExchangeFiles(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec source; + FSSpec dest; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSSpec, &source, + PyMac_GetFSSpec, &dest)) + return NULL; + _err = FSpExchangeFiles(&source, + &dest); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSpMakeFSRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSSpec source; + FSRef newRef; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSSpec, &source)) + return NULL; + _err = FSpMakeFSRef(&source, + &newRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSRef, &newRef); + return _res; +} + +static PyObject *File_FSMakeFSRefUnicode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef parentRef; + UniChar *nameLength__in__; + UniCharCount nameLength__len__; + int nameLength__in_len__; + TextEncoding textEncodingHint; + FSRef newRef; + if (!PyArg_ParseTuple(_args, "O&u#l", + PyMac_GetFSRef, &parentRef, + &nameLength__in__, &nameLength__in_len__, + &textEncodingHint)) + return NULL; + nameLength__len__ = nameLength__in_len__; + _err = FSMakeFSRefUnicode(&parentRef, + nameLength__len__, nameLength__in__, + textEncodingHint, + &newRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSRef, &newRef); + return _res; +} + +static PyObject *File_FSCompareFSRefs(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref1; + FSRef ref2; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSRef, &ref1, + PyMac_GetFSRef, &ref2)) + return NULL; + _err = FSCompareFSRefs(&ref1, + &ref2); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSDeleteObject(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &ref)) + return NULL; + _err = FSDeleteObject(&ref); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSMoveObject(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + FSRef destDirectory; + FSRef newRef; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSRef, &ref, + PyMac_GetFSRef, &destDirectory)) + return NULL; + _err = FSMoveObject(&ref, + &destDirectory, + &newRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSRef, &newRef); + return _res; +} + +static PyObject *File_FSExchangeObjects(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + FSRef destRef; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetFSRef, &ref, + PyMac_GetFSRef, &destRef)) + return NULL; + _err = FSExchangeObjects(&ref, + &destRef); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSRenameUnicode(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + UniChar *nameLength__in__; + UniCharCount nameLength__len__; + int nameLength__in_len__; + TextEncoding textEncodingHint; + FSRef newRef; + if (!PyArg_ParseTuple(_args, "O&u#l", + PyMac_GetFSRef, &ref, + &nameLength__in__, &nameLength__in_len__, + &textEncodingHint)) + return NULL; + nameLength__len__ = nameLength__in_len__; + _err = FSRenameUnicode(&ref, + nameLength__len__, nameLength__in__, + textEncodingHint, + &newRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSRef, &newRef); + return _res; +} + +static PyObject *File_FSCreateFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + if (!PyArg_ParseTuple(_args, "O&u#", + PyMac_GetFSRef, &ref, + &forkNameLength__in__, &forkNameLength__in_len__)) + return NULL; + forkNameLength__len__ = forkNameLength__in_len__; + _err = FSCreateFork(&ref, + forkNameLength__len__, forkNameLength__in__); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSDeleteFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + if (!PyArg_ParseTuple(_args, "O&u#", + PyMac_GetFSRef, &ref, + &forkNameLength__in__, &forkNameLength__in_len__)) + return NULL; + forkNameLength__len__ = forkNameLength__in_len__; + _err = FSDeleteFork(&ref, + forkNameLength__len__, forkNameLength__in__); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSOpenFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FSRef ref; + UniChar *forkNameLength__in__; + UniCharCount forkNameLength__len__; + int forkNameLength__in_len__; + SInt8 permissions; + SInt16 forkRefNum; + if (!PyArg_ParseTuple(_args, "O&u#b", + PyMac_GetFSRef, &ref, + &forkNameLength__in__, &forkNameLength__in_len__, + &permissions)) + return NULL; + forkNameLength__len__ = forkNameLength__in_len__; + _err = FSOpenFork(&ref, + forkNameLength__len__, forkNameLength__in__, + permissions, + &forkRefNum); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + forkRefNum); + return _res; +} + +static PyObject *File_FSGetForkPosition(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + SInt64 position; + if (!PyArg_ParseTuple(_args, "h", + &forkRefNum)) + return NULL; + _err = FSGetForkPosition(forkRefNum, + &position); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("L", + position); + return _res; +} + +static PyObject *File_FSSetForkPosition(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + UInt16 positionMode; + SInt64 positionOffset; + if (!PyArg_ParseTuple(_args, "hHL", + &forkRefNum, + &positionMode, + &positionOffset)) + return NULL; + _err = FSSetForkPosition(forkRefNum, + positionMode, + positionOffset); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSGetForkSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + SInt64 forkSize; + if (!PyArg_ParseTuple(_args, "h", + &forkRefNum)) + return NULL; + _err = FSGetForkSize(forkRefNum, + &forkSize); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("L", + forkSize); + return _res; +} + +static PyObject *File_FSSetForkSize(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + UInt16 positionMode; + SInt64 positionOffset; + if (!PyArg_ParseTuple(_args, "hHL", + &forkRefNum, + &positionMode, + &positionOffset)) + return NULL; + _err = FSSetForkSize(forkRefNum, + positionMode, + positionOffset); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSAllocateFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + FSAllocationFlags flags; + UInt16 positionMode; + SInt64 positionOffset; + UInt64 requestCount; + UInt64 actualCount; + if (!PyArg_ParseTuple(_args, "hHHLL", + &forkRefNum, + &flags, + &positionMode, + &positionOffset, + &requestCount)) + return NULL; + _err = FSAllocateFork(forkRefNum, + flags, + positionMode, + positionOffset, + requestCount, + &actualCount); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("L", + actualCount); + return _res; +} + +static PyObject *File_FSFlushFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + if (!PyArg_ParseTuple(_args, "h", + &forkRefNum)) + return NULL; + _err = FSFlushFork(forkRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSCloseFork(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + SInt16 forkRefNum; + if (!PyArg_ParseTuple(_args, "h", + &forkRefNum)) + return NULL; + _err = FSCloseFork(forkRefNum); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSGetDataForkName(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + HFSUniStr255 dataForkName; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = FSGetDataForkName(&dataForkName); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildHFSUniStr255, &dataForkName); + return _res; +} + +static PyObject *File_FSGetResourceForkName(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + HFSUniStr255 resourceForkName; + if (!PyArg_ParseTuple(_args, "")) + return NULL; + _err = FSGetResourceForkName(&resourceForkName); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildHFSUniStr255, &resourceForkName); + return _res; +} + +static PyObject *File_FSPathMakeRef(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + char* path; + FSRef ref; + Boolean isDirectory; + if (!PyArg_ParseTuple(_args, "s", + &path)) + return NULL; + _err = FSPathMakeRef(path, + &ref, + &isDirectory); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&b", + PyMac_BuildFSRef, &ref, + isDirectory); + return _res; +} + +static PyObject *File_FNNotify(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + FSRef ref; + FNMessage message; + OptionBits flags; + if (!PyArg_ParseTuple(_args, "O&ll", + PyMac_GetFSRef, &ref, + &message, + &flags)) + return NULL; + _err = FNNotify(&ref, + message, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FNNotifyByPath(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + char* path; + FNMessage message; + OptionBits flags; + if (!PyArg_ParseTuple(_args, "sll", + &path, + &message, + &flags)) + return NULL; + _err = FNNotifyByPath(path, + message, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FNNotifyAll(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSStatus _err; + FNMessage message; + OptionBits flags; + if (!PyArg_ParseTuple(_args, "ll", + &message, + &flags)) + return NULL; + _err = FNNotifyAll(message, + flags); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *File_FSRefMakePath(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + + OSStatus _err; + FSRef ref; +#define MAXPATHNAME 1024 + UInt8 path[MAXPATHNAME]; + UInt32 maxPathSize = MAXPATHNAME; + + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &ref)) + return NULL; + _err = FSRefMakePath(&ref, + path, + maxPathSize); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("s", path); + return _res; + +} + +static PyMethodDef File_methods[] = { + {"UnmountVol", (PyCFunction)File_UnmountVol, 1, + PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, + {"FlushVol", (PyCFunction)File_FlushVol, 1, + PyDoc_STR("(Str63 volName, short vRefNum) -> None")}, + {"HSetVol", (PyCFunction)File_HSetVol, 1, + PyDoc_STR("(Str63 volName, short vRefNum, long dirID) -> None")}, + {"FSClose", (PyCFunction)File_FSClose, 1, + PyDoc_STR("(short refNum) -> None")}, + {"Allocate", (PyCFunction)File_Allocate, 1, + PyDoc_STR("(short refNum) -> (long count)")}, + {"GetEOF", (PyCFunction)File_GetEOF, 1, + PyDoc_STR("(short refNum) -> (long logEOF)")}, + {"SetEOF", (PyCFunction)File_SetEOF, 1, + PyDoc_STR("(short refNum, long logEOF) -> None")}, + {"GetFPos", (PyCFunction)File_GetFPos, 1, + PyDoc_STR("(short refNum) -> (long filePos)")}, + {"SetFPos", (PyCFunction)File_SetFPos, 1, + PyDoc_STR("(short refNum, short posMode, long posOff) -> None")}, + {"GetVRefNum", (PyCFunction)File_GetVRefNum, 1, + PyDoc_STR("(short fileRefNum) -> (short vRefNum)")}, + {"HGetVol", (PyCFunction)File_HGetVol, 1, + PyDoc_STR("(StringPtr volName) -> (short vRefNum, long dirID)")}, + {"HOpen", (PyCFunction)File_HOpen, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, + {"HOpenDF", (PyCFunction)File_HOpenDF, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, + {"HOpenRF", (PyCFunction)File_HOpenRF, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, SInt8 permission) -> (short refNum)")}, + {"AllocContig", (PyCFunction)File_AllocContig, 1, + PyDoc_STR("(short refNum) -> (long count)")}, + {"HCreate", (PyCFunction)File_HCreate, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, OSType creator, OSType fileType) -> None")}, + {"DirCreate", (PyCFunction)File_DirCreate, 1, + PyDoc_STR("(short vRefNum, long parentDirID, Str255 directoryName) -> (long createdDirID)")}, + {"HDelete", (PyCFunction)File_HDelete, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, + {"HGetFInfo", (PyCFunction)File_HGetFInfo, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FInfo fndrInfo)")}, + {"HSetFInfo", (PyCFunction)File_HSetFInfo, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName, FInfo fndrInfo) -> None")}, + {"HSetFLock", (PyCFunction)File_HSetFLock, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, + {"HRstFLock", (PyCFunction)File_HRstFLock, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> None")}, + {"HRename", (PyCFunction)File_HRename, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, Str255 newName) -> None")}, + {"CatMove", (PyCFunction)File_CatMove, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 oldName, long newDirID, Str255 newName) -> None")}, + {"FSMakeFSSpec", (PyCFunction)File_FSMakeFSSpec, 1, + PyDoc_STR("(short vRefNum, long dirID, Str255 fileName) -> (FSSpec spec)")}, + {"FSpOpenDF", (PyCFunction)File_FSpOpenDF, 1, + PyDoc_STR("(FSSpec spec, SInt8 permission) -> (short refNum)")}, + {"FSpOpenRF", (PyCFunction)File_FSpOpenRF, 1, + PyDoc_STR("(FSSpec spec, SInt8 permission) -> (short refNum)")}, + {"FSpCreate", (PyCFunction)File_FSpCreate, 1, + PyDoc_STR("(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None")}, + {"FSpDirCreate", (PyCFunction)File_FSpDirCreate, 1, + PyDoc_STR("(FSSpec spec, ScriptCode scriptTag) -> (long createdDirID)")}, + {"FSpDelete", (PyCFunction)File_FSpDelete, 1, + PyDoc_STR("(FSSpec spec) -> None")}, + {"FSpGetFInfo", (PyCFunction)File_FSpGetFInfo, 1, + PyDoc_STR("(FSSpec spec) -> (FInfo fndrInfo)")}, + {"FSpSetFInfo", (PyCFunction)File_FSpSetFInfo, 1, + PyDoc_STR("(FSSpec spec, FInfo fndrInfo) -> None")}, + {"FSpSetFLock", (PyCFunction)File_FSpSetFLock, 1, + PyDoc_STR("(FSSpec spec) -> None")}, + {"FSpRstFLock", (PyCFunction)File_FSpRstFLock, 1, + PyDoc_STR("(FSSpec spec) -> None")}, + {"FSpRename", (PyCFunction)File_FSpRename, 1, + PyDoc_STR("(FSSpec spec, Str255 newName) -> None")}, + {"FSpCatMove", (PyCFunction)File_FSpCatMove, 1, + PyDoc_STR("(FSSpec source, FSSpec dest) -> None")}, + {"FSpExchangeFiles", (PyCFunction)File_FSpExchangeFiles, 1, + PyDoc_STR("(FSSpec source, FSSpec dest) -> None")}, + {"FSpMakeFSRef", (PyCFunction)File_FSpMakeFSRef, 1, + PyDoc_STR("(FSSpec source) -> (FSRef newRef)")}, + {"FSMakeFSRefUnicode", (PyCFunction)File_FSMakeFSRefUnicode, 1, + PyDoc_STR("(FSRef parentRef, Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")}, + {"FSCompareFSRefs", (PyCFunction)File_FSCompareFSRefs, 1, + PyDoc_STR("(FSRef ref1, FSRef ref2) -> None")}, + {"FSDeleteObject", (PyCFunction)File_FSDeleteObject, 1, + PyDoc_STR("(FSRef ref) -> None")}, + {"FSMoveObject", (PyCFunction)File_FSMoveObject, 1, + PyDoc_STR("(FSRef ref, FSRef destDirectory) -> (FSRef newRef)")}, + {"FSExchangeObjects", (PyCFunction)File_FSExchangeObjects, 1, + PyDoc_STR("(FSRef ref, FSRef destRef) -> None")}, + {"FSRenameUnicode", (PyCFunction)File_FSRenameUnicode, 1, + PyDoc_STR("(FSRef ref, Buffer nameLength, TextEncoding textEncodingHint) -> (FSRef newRef)")}, + {"FSCreateFork", (PyCFunction)File_FSCreateFork, 1, + PyDoc_STR("(FSRef ref, Buffer forkNameLength) -> None")}, + {"FSDeleteFork", (PyCFunction)File_FSDeleteFork, 1, + PyDoc_STR("(FSRef ref, Buffer forkNameLength) -> None")}, + {"FSOpenFork", (PyCFunction)File_FSOpenFork, 1, + PyDoc_STR("(FSRef ref, Buffer forkNameLength, SInt8 permissions) -> (SInt16 forkRefNum)")}, + {"FSGetForkPosition", (PyCFunction)File_FSGetForkPosition, 1, + PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 position)")}, + {"FSSetForkPosition", (PyCFunction)File_FSSetForkPosition, 1, + PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, + {"FSGetForkSize", (PyCFunction)File_FSGetForkSize, 1, + PyDoc_STR("(SInt16 forkRefNum) -> (SInt64 forkSize)")}, + {"FSSetForkSize", (PyCFunction)File_FSSetForkSize, 1, + PyDoc_STR("(SInt16 forkRefNum, UInt16 positionMode, SInt64 positionOffset) -> None")}, + {"FSAllocateFork", (PyCFunction)File_FSAllocateFork, 1, + PyDoc_STR("(SInt16 forkRefNum, FSAllocationFlags flags, UInt16 positionMode, SInt64 positionOffset, UInt64 requestCount) -> (UInt64 actualCount)")}, + {"FSFlushFork", (PyCFunction)File_FSFlushFork, 1, + PyDoc_STR("(SInt16 forkRefNum) -> None")}, + {"FSCloseFork", (PyCFunction)File_FSCloseFork, 1, + PyDoc_STR("(SInt16 forkRefNum) -> None")}, + {"FSGetDataForkName", (PyCFunction)File_FSGetDataForkName, 1, + PyDoc_STR("() -> (HFSUniStr255 dataForkName)")}, + {"FSGetResourceForkName", (PyCFunction)File_FSGetResourceForkName, 1, + PyDoc_STR("() -> (HFSUniStr255 resourceForkName)")}, + {"FSPathMakeRef", (PyCFunction)File_FSPathMakeRef, 1, + PyDoc_STR("(char* path) -> (FSRef ref, Boolean isDirectory)")}, + {"FNNotify", (PyCFunction)File_FNNotify, 1, + PyDoc_STR("(FSRef ref, FNMessage message, OptionBits flags) -> None")}, + {"FNNotifyByPath", (PyCFunction)File_FNNotifyByPath, 1, + PyDoc_STR("(char* path, FNMessage message, OptionBits flags) -> None")}, + {"FNNotifyAll", (PyCFunction)File_FNNotifyAll, 1, + PyDoc_STR("(FNMessage message, OptionBits flags) -> None")}, + {"FSRefMakePath", (PyCFunction)File_FSRefMakePath, 1, + PyDoc_STR("(FSRef) -> string")}, + {NULL, NULL, 0} +}; + + + + +void init_File(void) +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("_File", File_methods); + d = PyModule_GetDict(m); + File_Error = PyMac_GetOSErrException(); + if (File_Error == NULL || + PyDict_SetItemString(d, "Error", File_Error) != 0) + return; +} + +/* ======================== End module _File ======================== */ + diff --git a/Mac/Modules/file/filescan.py b/Mac/Modules/file/filescan.py new file mode 100644 index 00000000000..7a96d695351 --- /dev/null +++ b/Mac/Modules/file/filescan.py @@ -0,0 +1,152 @@ +# Scan an Apple header file, generating a Python file of generator calls. + +import sys +import os +from bgenlocations import TOOLBOXDIR, BGENDIR +sys.path.append(BGENDIR) +from scantools import Scanner_OSX + +LONG = "Files" +SHORT = "file" +OBJECT = "NOTUSED" + +def main(): + input = LONG + ".h" + output = SHORT + "gen.py" + defsoutput = TOOLBOXDIR + LONG + ".py" + scanner = MyScanner(input, output, defsoutput) + scanner.scan() + scanner.close() + scanner.gentypetest(SHORT+"typetest.py") + print "=== Testing definitions output code ===" + execfile(defsoutput, {}, {}) + print "=== Done scanning and generating, now importing the generated code... ===" + exec "import " + SHORT + "support" + print "=== Done. It's up to you to compile it now! ===" + +class MyScanner(Scanner_OSX): + + def destination(self, type, name, arglist): + classname = "Function" + listname = "functions" + if arglist: + t, n, m = arglist[0] + # This is non-functional today + if t == OBJECT and m == "InMode": + classname = "Method" + listname = "methods" + return classname, listname + + def makeblacklistnames(self): + return [ + # Constants with incompatible definitions + "kioACAccessOwnerMask", + "kFSCatInfoReserved", + "kFSIterateReserved", + + "FSRefMakePath", # Do this manually + + "FSRead", # Couldn't be bothered + "FSWrite", # ditto + "FSReadFork", # ditto + "FSWriteFork", # ditto + + # Old routines: + "GetWDInfo", + "OpenWD", + "CloseWD", + "FInitQueue", + "rstflock", + "setflock", + "setfinfo", + "fsrename", + "fsdelete", + "create", + "flushvol", + "eject", + "umountvol", + "setvol", + "getvol", + "getfinfo", + "getvinfo", + "fsopen", + "RstFLock", + "SetFLock", + "SetFInfo", + "Rename", + "OpenRF", + "FSDelete", + "Create", + "GetVol", + "GetFInfo", + "GetVInfo", + "FSOpen", + "Eject", + "SetVol", + "openrf", + "unmountvol", + "OpenDF", + + ] + + def makeblacklisttypes(self): + return [ + "CInfoPBPtr", # Old stuff + "CMovePBPtr", # Old stuff + "ParmBlkPtr", # Old stuff + "HParmBlkPtr", # Old stuff + "DTPBPtr", # Old stuff + "FCBPBPtr", # Old stuff + "QHdrPtr", # Old stuff + "CSParamPtr", # Old stuff + "FSCatalogBulkParam", # old stuff + "FSForkCBInfoParam", # old stuff + "FSForkIOParam", # old stuff + "FSRefParam", # old stuff + "FSVolumeInfoParam", # old stuff + "WDPBPtr", # old stuff + "XCInfoPBPtr", # old stuff + "XVolumeParamPtr", # old stuff + + + "CatPositionRec", # State variable, not too difficult + "FSCatalogInfo", # Lots of fields, difficult struct + "FSCatalogInfo_ptr", # Lots of fields, difficult struct + "FSIterator", # Should become an object + "FSForkInfo", # Lots of fields, difficult struct + "FSSearchParams", # Also catsearch stuff + "FSVolumeInfo", # big struct + "FSVolumeInfo_ptr", # big struct + + "IOCompletionProcPtr", # proc pointer + "IOCompletionUPP", # Proc pointer + + + ] + + def makerepairinstructions(self): + return [ + # Various ways to give pathnames + ([('UInt8_ptr', 'path', 'InMode')], + [('stringptr', 'path', 'InMode')] + ), + + ([('char_ptr', '*', 'InMode')], + [('stringptr', '*', 'InMode')] + ), + + # Unicode filenames passed as length, buffer + ([('UniCharCount', '*', 'InMode'), + ('UniChar_ptr', '*', 'InMode')], + [('UnicodeReverseInBuffer', '*', 'InMode')] + ), + ] + + + def writeinitialdefs(self): + self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n") + self.defsfile.write("true = True\n") + self.defsfile.write("false = False\n") + +if __name__ == "__main__": + main() diff --git a/Mac/Modules/file/filesupport.py b/Mac/Modules/file/filesupport.py new file mode 100644 index 00000000000..a009c3dcba6 --- /dev/null +++ b/Mac/Modules/file/filesupport.py @@ -0,0 +1,156 @@ +# This script generates a Python interface for an Apple Macintosh Manager. +# It uses the "bgen" package to generate C code. +# The function specifications are generated by scanning the mamager's header file, +# using the "scantools" package (customized for this particular manager). + +import string + +# Declarations that change for each manager +MACHEADERFILE = 'Files.h' # The Apple header file +MODNAME = '_File' # The name of the module + +# The following is *usually* unchanged but may still require tuning +MODPREFIX = 'File' # The prefix for module-wide routines +INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner +OUTPUTFILE = MODNAME + "module.c" # The file generated by this program + +from macsupport import * + +# Create the type objects +#ConstStrFileNameParam = ConstStr255Param +#StrFileName = Str255 +#FolderClass = OSTypeType("FolderClass") +# FolderDesc +#FolderDescFlags = Type("FolderDescFlags", "l") +#FolderLocation = OSTypeType("FolderLocation") +# FolderRouting +#FolderType = OSTypeType("FolderType") +#RoutingFlags = Type("RoutingFlags", "l") + +class UniCharCountBuffer(InputOnlyType): + pass + +#CatPositionRec +ConstStr63Param = OpaqueArrayType("Str63", "PyMac_BuildStr255", "PyMac_GetStr255") +FInfo = OpaqueByValueStructType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo") +FInfo_ptr = OpaqueType("FInfo", "PyMac_BuildFInfo", "PyMac_GetFInfo") +FNMessage = Type("FNMessage", "l") +FSAllocationFlags = Type("FSAllocationFlags", "H") +#FSCatalogInfo +FSCatalogInfoBitmap = Type("FSCatalogInfoBitmap", "l") +#FSForkInfo +#FSIterator +FSIteratorFlags = Type("FSIteratorFlags", "l") +#FSVolumeInfo +FSVolumeRefNum = Type("FSVolumeRefNum", "h") +HFSUniStr255 = OpaqueType("HFSUniStr255", "PyMac_BuildHFSUniStr255", "PyMac_GetHFSUniStr255") +SInt64 = Type("SInt64", "L") +UInt64 = Type("UInt64", "L") +#UInt8_ptr +#UniCharCount +#char_ptr +#void_ptr + + +includestuff = includestuff + """ +#ifdef WITHOUT_FRAMEWORKS +#include +#else +#include +#endif + +/* +** Parse/generate objsect +*/ +static PyObject * +PyMac_BuildHFSUniStr255(HFSUniStr255 *itself) +{ + + return Py_BuildValue("u#", itself->unicode, itself->length); +} + +#if 0 +static int +PyMac_GetHFSUniStr255(PyObject *v, HFSUniStr255 *itself) +{ + return PyArg_ParseTuple(v, "O&O&O&O&O&", + PyMac_GetFixed, &itself->ascent, + PyMac_GetFixed, &itself->descent, + PyMac_GetFixed, &itself->leading, + PyMac_GetFixed, &itself->widMax, + ResObj_Convert, &itself->wTabHandle); +} +#endif + +/* +** Parse/generate objsect +*/ +static PyObject * +PyMac_BuildFInfo(FInfo *itself) +{ + + return Py_BuildValue("O&O&HO&h", + PyMac_BuildOSType, itself->fdType, + PyMac_BuildOSType, itself->fdCreator, + itself->fdFlags, + PyMac_BuildPoint, &itself->fdLocation, + itself->fdFldr); +} + +static int +PyMac_GetFInfo(PyObject *v, FInfo *itself) +{ + return PyArg_ParseTuple(v, "O&O&HO&h", + PyMac_GetOSType, &itself->fdType, + PyMac_GetOSType, &itself->fdCreator, + &itself->fdFlags, + PyMac_GetPoint, &itself->fdLocation, + &itself->fdFldr); +} + +""" + +execfile(string.lower(MODPREFIX) + 'typetest.py') + +# From here on it's basically all boiler plate... + +# Create the generator groups and link them +module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) + +# Create the generator classes used to populate the lists +Function = OSErrFunctionGenerator + +# Create and populate the lists +functions = [] +execfile(INPUTFILE) + +# Manual generators: +FSRefMakePath_body = """ +OSStatus _err; +FSRef ref; +#define MAXPATHNAME 1024 +UInt8 path[MAXPATHNAME]; +UInt32 maxPathSize = MAXPATHNAME; + +if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetFSRef, &ref)) + return NULL; +_err = FSRefMakePath(&ref, + path, + maxPathSize); +if (_err != noErr) return PyMac_Error(_err); +_res = Py_BuildValue("s", path); +return _res; +""" +f = ManualGenerator("FSRefMakePath", FSRefMakePath_body) +f.docstring = lambda: "(FSRef) -> string" +functions.append(f) + +# add the populated lists to the generator groups +# (in a different wordl the scan program would generate this) +for f in functions: module.add(f) + +# generate output (open the output file as late as possible) +SetOutputFileName(OUTPUTFILE) +module.generate() + diff --git a/Mac/Modules/folder/_Foldermodule.c b/Mac/Modules/folder/_Foldermodule.c new file mode 100644 index 00000000000..07d7bf544b9 --- /dev/null +++ b/Mac/Modules/folder/_Foldermodule.c @@ -0,0 +1,347 @@ + +/* ========================= Module _Folder ========================= */ + +#include "Python.h" + + + +#ifdef _WIN32 +#include "pywintoolbox.h" +#else +#include "macglue.h" +#include "pymactoolbox.h" +#endif + +/* Macro to test whether a weak-loaded CFM function exists */ +#define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL ) {\ + PyErr_SetString(PyExc_NotImplementedError, \ + "Not available in this shared library/OS version"); \ + return NULL; \ + }} while(0) + + +#ifdef WITHOUT_FRAMEWORKS +#include +#else +#include +#endif + + +static PyObject *Folder_Error; + +static PyObject *Folder_FindFolder(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + OSType folderType; + Boolean createFolder; + short foundVRefNum; + long foundDirID; + if (!PyArg_ParseTuple(_args, "hO&b", + &vRefNum, + PyMac_GetOSType, &folderType, + &createFolder)) + return NULL; + _err = FindFolder(vRefNum, + folderType, + createFolder, + &foundVRefNum, + &foundDirID); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("hl", + foundVRefNum, + foundDirID); + return _res; +} + +static PyObject *Folder_ReleaseFolder(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + OSType folderType; + if (!PyArg_ParseTuple(_args, "hO&", + &vRefNum, + PyMac_GetOSType, &folderType)) + return NULL; + _err = ReleaseFolder(vRefNum, + folderType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_FSFindFolder(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + OSType folderType; + Boolean createFolder; + FSRef foundRef; + if (!PyArg_ParseTuple(_args, "hO&b", + &vRefNum, + PyMac_GetOSType, &folderType, + &createFolder)) + return NULL; + _err = FSFindFolder(vRefNum, + folderType, + createFolder, + &foundRef); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildFSRef, &foundRef); + return _res; +} + +static PyObject *Folder_AddFolderDescriptor(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FolderType foldType; + FolderDescFlags flags; + FolderClass foldClass; + FolderLocation foldLocation; + OSType badgeSignature; + OSType badgeType; + Str255 name; + Boolean replaceFlag; + if (!PyArg_ParseTuple(_args, "O&lO&O&O&O&O&b", + PyMac_GetOSType, &foldType, + &flags, + PyMac_GetOSType, &foldClass, + PyMac_GetOSType, &foldLocation, + PyMac_GetOSType, &badgeSignature, + PyMac_GetOSType, &badgeType, + PyMac_GetStr255, name, + &replaceFlag)) + return NULL; + _err = AddFolderDescriptor(foldType, + flags, + foldClass, + foldLocation, + badgeSignature, + badgeType, + name, + replaceFlag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_GetFolderTypes(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + UInt32 requestedTypeCount; + UInt32 totalTypeCount; + FolderType theTypes; + if (!PyArg_ParseTuple(_args, "l", + &requestedTypeCount)) + return NULL; + _err = GetFolderTypes(requestedTypeCount, + &totalTypeCount, + &theTypes); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("lO&", + totalTypeCount, + PyMac_BuildOSType, theTypes); + return _res; +} + +static PyObject *Folder_RemoveFolderDescriptor(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + FolderType foldType; + if (!PyArg_ParseTuple(_args, "O&", + PyMac_GetOSType, &foldType)) + return NULL; + _err = RemoveFolderDescriptor(foldType); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_GetFolderName(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + OSType foldType; + short foundVRefNum; + Str255 name; + if (!PyArg_ParseTuple(_args, "hO&O&", + &vRefNum, + PyMac_GetOSType, &foldType, + PyMac_GetStr255, name)) + return NULL; + _err = GetFolderName(vRefNum, + foldType, + &foundVRefNum, + name); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("h", + foundVRefNum); + return _res; +} + +static PyObject *Folder_AddFolderRouting(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType fileType; + FolderType routeFromFolder; + FolderType routeToFolder; + RoutingFlags flags; + Boolean replaceFlag; + if (!PyArg_ParseTuple(_args, "O&O&O&lb", + PyMac_GetOSType, &fileType, + PyMac_GetOSType, &routeFromFolder, + PyMac_GetOSType, &routeToFolder, + &flags, + &replaceFlag)) + return NULL; + _err = AddFolderRouting(fileType, + routeFromFolder, + routeToFolder, + flags, + replaceFlag); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_RemoveFolderRouting(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType fileType; + FolderType routeFromFolder; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &fileType, + PyMac_GetOSType, &routeFromFolder)) + return NULL; + _err = RemoveFolderRouting(fileType, + routeFromFolder); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_FindFolderRouting(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + OSType fileType; + FolderType routeFromFolder; + FolderType routeToFolder; + RoutingFlags flags; + if (!PyArg_ParseTuple(_args, "O&O&", + PyMac_GetOSType, &fileType, + PyMac_GetOSType, &routeFromFolder)) + return NULL; + _err = FindFolderRouting(fileType, + routeFromFolder, + &routeToFolder, + &flags); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&l", + PyMac_BuildOSType, routeToFolder, + flags); + return _res; +} + +static PyObject *Folder_InvalidateFolderDescriptorCache(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + if (!PyArg_ParseTuple(_args, "hl", + &vRefNum, + &dirID)) + return NULL; + _err = InvalidateFolderDescriptorCache(vRefNum, + dirID); + if (_err != noErr) return PyMac_Error(_err); + Py_INCREF(Py_None); + _res = Py_None; + return _res; +} + +static PyObject *Folder_IdentifyFolder(PyObject *_self, PyObject *_args) +{ + PyObject *_res = NULL; + OSErr _err; + short vRefNum; + long dirID; + FolderType foldType; + if (!PyArg_ParseTuple(_args, "hl", + &vRefNum, + &dirID)) + return NULL; + _err = IdentifyFolder(vRefNum, + dirID, + &foldType); + if (_err != noErr) return PyMac_Error(_err); + _res = Py_BuildValue("O&", + PyMac_BuildOSType, foldType); + return _res; +} + +static PyMethodDef Folder_methods[] = { + {"FindFolder", (PyCFunction)Folder_FindFolder, 1, + PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (short foundVRefNum, long foundDirID)")}, + {"ReleaseFolder", (PyCFunction)Folder_ReleaseFolder, 1, + PyDoc_STR("(short vRefNum, OSType folderType) -> None")}, + {"FSFindFolder", (PyCFunction)Folder_FSFindFolder, 1, + PyDoc_STR("(short vRefNum, OSType folderType, Boolean createFolder) -> (FSRef foundRef)")}, + {"AddFolderDescriptor", (PyCFunction)Folder_AddFolderDescriptor, 1, + PyDoc_STR("(FolderType foldType, FolderDescFlags flags, FolderClass foldClass, FolderLocation foldLocation, OSType badgeSignature, OSType badgeType, Str255 name, Boolean replaceFlag) -> None")}, + {"GetFolderTypes", (PyCFunction)Folder_GetFolderTypes, 1, + PyDoc_STR("(UInt32 requestedTypeCount) -> (UInt32 totalTypeCount, FolderType theTypes)")}, + {"RemoveFolderDescriptor", (PyCFunction)Folder_RemoveFolderDescriptor, 1, + PyDoc_STR("(FolderType foldType) -> None")}, + {"GetFolderName", (PyCFunction)Folder_GetFolderName, 1, + PyDoc_STR("(short vRefNum, OSType foldType, Str255 name) -> (short foundVRefNum)")}, + {"AddFolderRouting", (PyCFunction)Folder_AddFolderRouting, 1, + PyDoc_STR("(OSType fileType, FolderType routeFromFolder, FolderType routeToFolder, RoutingFlags flags, Boolean replaceFlag) -> None")}, + {"RemoveFolderRouting", (PyCFunction)Folder_RemoveFolderRouting, 1, + PyDoc_STR("(OSType fileType, FolderType routeFromFolder) -> None")}, + {"FindFolderRouting", (PyCFunction)Folder_FindFolderRouting, 1, + PyDoc_STR("(OSType fileType, FolderType routeFromFolder) -> (FolderType routeToFolder, RoutingFlags flags)")}, + {"InvalidateFolderDescriptorCache", (PyCFunction)Folder_InvalidateFolderDescriptorCache, 1, + PyDoc_STR("(short vRefNum, long dirID) -> None")}, + {"IdentifyFolder", (PyCFunction)Folder_IdentifyFolder, 1, + PyDoc_STR("(short vRefNum, long dirID) -> (FolderType foldType)")}, + {NULL, NULL, 0} +}; + + + + +void init_Folder(void) +{ + PyObject *m; + PyObject *d; + + + + + m = Py_InitModule("_Folder", Folder_methods); + d = PyModule_GetDict(m); + Folder_Error = PyMac_GetOSErrException(); + if (Folder_Error == NULL || + PyDict_SetItemString(d, "Error", Folder_Error) != 0) + return; +} + +/* ======================= End module _Folder ======================= */ + diff --git a/Mac/Modules/folder/folderscan.py b/Mac/Modules/folder/folderscan.py new file mode 100644 index 00000000000..39b5a0552af --- /dev/null +++ b/Mac/Modules/folder/folderscan.py @@ -0,0 +1,68 @@ +# Scan an Apple header file, generating a Python file of generator calls. + +import sys +import os +from bgenlocations import TOOLBOXDIR, BGENDIR +sys.path.append(BGENDIR) +from scantools import Scanner_OSX + +LONG = "Folders" +SHORT = "folder" +OBJECT = "NOTUSED" + +def main(): + input = LONG + ".h" + output = SHORT + "gen.py" + defsoutput = TOOLBOXDIR + LONG + ".py" + scanner = MyScanner(input, output, defsoutput) + scanner.scan() + scanner.close() + scanner.gentypetest(SHORT+"typetest.py") + print "=== Testing definitions output code ===" + execfile(defsoutput, {}, {}) + print "=== Done scanning and generating, now importing the generated code... ===" + exec "import " + SHORT + "support" + print "=== Done. It's up to you to compile it now! ===" + +class MyScanner(Scanner_OSX): + + def destination(self, type, name, arglist): + classname = "Function" + listname = "functions" + if arglist: + t, n, m = arglist[0] + # This is non-functional today + if t == OBJECT and m == "InMode": + classname = "Method" + listname = "methods" + return classname, listname + + def makeblacklistnames(self): + return [ + "FindFolderExtended", # Has funny void* argument + "FSFindFolderExtended", # ditto + "FolderManagerRegisterCallNotificationProcs", # ditto + + "FindFolderEx", # Non-MacOS routine + ] + + def makeblacklisttypes(self): + return [ + "FolderManagerNotificationProcPtr", + "FolderManagerNotificationUPP", + "FolderRouting", # To be done, not difficult + "FolderDesc", # To be done, not difficult + + ] + + def makerepairinstructions(self): + return [ + ] + + def writeinitialdefs(self): + self.defsfile.write("def FOUR_CHAR_CODE(x): return x\n") + self.defsfile.write("true = True\n") + self.defsfile.write("false = False\n") + +if __name__ == "__main__": + main() diff --git a/Mac/Modules/folder/foldersupport.py b/Mac/Modules/folder/foldersupport.py new file mode 100644 index 00000000000..92003e8396f --- /dev/null +++ b/Mac/Modules/folder/foldersupport.py @@ -0,0 +1,61 @@ +# This script generates a Python interface for an Apple Macintosh Manager. +# It uses the "bgen" package to generate C code. +# The function specifications are generated by scanning the mamager's header file, +# using the "scantools" package (customized for this particular manager). + +import string + +# Declarations that change for each manager +MACHEADERFILE = 'Folders.h' # The Apple header file +MODNAME = '_Folder' # The name of the module + +# The following is *usually* unchanged but may still require tuning +MODPREFIX = 'Folder' # The prefix for module-wide routines +INPUTFILE = string.lower(MODPREFIX) + 'gen.py' # The file generated by the scanner +OUTPUTFILE = MODNAME + "module.c" # The file generated by this program + +from macsupport import * + +# Create the type objects +ConstStrFileNameParam = ConstStr255Param +StrFileName = Str255 +FolderClass = OSTypeType("FolderClass") +# FolderDesc +FolderDescFlags = Type("FolderDescFlags", "l") +FolderLocation = OSTypeType("FolderLocation") +# FolderRouting +FolderType = OSTypeType("FolderType") +RoutingFlags = Type("RoutingFlags", "l") + + +includestuff = includestuff + """ +#ifdef WITHOUT_FRAMEWORKS +#include +#else +#include +#endif + +""" + +execfile(string.lower(MODPREFIX) + 'typetest.py') + +# From here on it's basically all boiler plate... + +# Create the generator groups and link them +module = MacModule(MODNAME, MODPREFIX, includestuff, finalstuff, initstuff) + +# Create the generator classes used to populate the lists +Function = OSErrFunctionGenerator + +# Create and populate the lists +functions = [] +execfile(INPUTFILE) + +# add the populated lists to the generator groups +# (in a different wordl the scan program would generate this) +for f in functions: module.add(f) + +# generate output (open the output file as late as possible) +SetOutputFileName(OUTPUTFILE) +module.generate() + diff --git a/setup.py b/setup.py index f471c03b243..6ce993df374 100644 --- a/setup.py +++ b/setup.py @@ -745,6 +745,10 @@ class PyBuildExt(build_ext): extra_link_args=['-framework', 'Carbon']) ) exts.append( Extension('_Evt', ['evt/_Evtmodule.c'], extra_link_args=['-framework', 'Carbon']) ) + exts.append( Extension('_File', ['file/_Filemodule.c'], + extra_link_args=['-framework', 'Carbon']) ) + exts.append( Extension('_Folder', ['folder/_Foldermodule.c'], + extra_link_args=['-framework', 'Carbon']) ) exts.append( Extension('_Fm', ['fm/_Fmmodule.c'], extra_link_args=['-framework', 'Carbon']) ) exts.append( Extension('_Help', ['help/_Helpmodule.c'],