+17

src/frameworks/Bom/CMakeLists.txt

reviewed

··· 1 1 + project(Bom) 2 2 + 3 3 + set(DYLIB_COMPAT_VERSION "2.0.0") 4 4 + set(DYLIB_CURRENT_VERSION "195.0.0") 5 5 + 6 6 + add_framework(Bom 7 7 + FAT 8 8 + CURRENT_VERSION 9 9 + PRIVATE 10 10 + VERSION "A" 11 11 + 12 12 + SOURCES 13 13 + src/Bom.c 14 14 + 15 15 + DEPENDENCIES 16 16 + system 17 17 + )

+434

src/frameworks/Bom/include/Bom/Bom.h

reviewed

··· 1 1 + /* 2 2 + This file is part of Darling. 3 3 + 4 4 + Copyright (C) 2019 Lubos Dolezel 5 5 + 6 6 + Darling is free software: you can redistribute it and/or modify 7 7 + it under the terms of the GNU General Public License as published by 8 8 + the Free Software Foundation, either version 3 of the License, or 9 9 + (at your option) any later version. 10 10 + 11 11 + Darling is distributed in the hope that it will be useful, 12 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 14 + GNU General Public License for more details. 15 15 + 16 16 + You should have received a copy of the GNU General Public License 17 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 18 + */ 19 19 + 20 20 + 21 21 + #ifndef _Bom_H_ 22 22 + #define _Bom_H_ 23 23 + 24 24 + void* BOMAppleDoubleADPathToPath(void); 25 25 + void* BOMAppleDoubleCopyHeader(void); 26 26 + void* BOMAppleDoubleIsADFile(void); 27 27 + void* BOMAppleDoublePathToADPath(void); 28 28 + void* BOMAppleDoubleReadHeader(void); 29 29 + void* BOMAppleDoubleSize(void); 30 30 + void* BOMAppleDoubleWriteHeader(void); 31 31 + void* BOMArchFlagForFile(void); 32 32 + void* BOMArchFlagForFileWithSys(void); 33 33 + void* BOMArchFlagForHeader(void); 34 34 + void* BOMBomApproximateBytesRepresented(void); 35 35 + void* BOMBomApproximateBytesRepresented64(void); 36 36 + void* BOMBomApproximateBytesRepresentedByVariant(void); 37 37 + void* BOMBomApproximateBytesRepresentedByVariant64(void); 38 38 + void* BOMBomApproximateBytesRepresentedByVariantIsValid(void); 39 39 + void* BOMBomApproximateBytesRepresentedByVariantWithBlockSize(void); 40 40 + void* BOMBomApproximateBytesRepresentedByVariantWithBlockSize64(void); 41 41 + void* BOMBomApproximateBytesRepresentedWithBlockSize(void); 42 42 + void* BOMBomApproximateBytesRepresentedWithBlockSize64(void); 43 43 + void* BOMBomCommit(void); 44 44 + void* BOMBomDumpLinks(void); 45 45 + void* BOMBomEInsertFSObject(void); 46 46 + void* BOMBomEInvalidateCachedData(void); 47 47 + void* BOMBomELinkFromPathToPath(void); 48 48 + void* BOMBomEnumeratorFree(void); 49 49 + void* BOMBomEnumeratorNew(void); 50 50 + void* BOMBomEnumeratorNewWithOptions(void); 51 51 + void* BOMBomEnumeratorNext(void); 52 52 + void* BOMBomEnumeratorSkip(void); 53 53 + void* BOMBomEnumeratorSkipAll(void); 54 54 + void* BOMBomFSObjectCount(void); 55 55 + void* BOMBomFSObjectExistsAtPath(void); 56 56 + void* BOMBomFree(void); 57 57 + void* BOMBomGetFSObjectAtPath(void); 58 58 + void* BOMBomGetRootFSObject(void); 59 59 + void* BOMBomInsertFSObject(void); 60 60 + void* BOMBomLinkToFSObjectFromPath(void); 61 61 + void* BOMBomLinkToPathFromPath(void); 62 62 + void* BOMBomMaskWithBom(void); 63 63 + void* BOMBomMaskWithPatternList(void); 64 64 + void* BOMBomMergeInto(void); 65 65 + void* BOMBomMergeIntoBom(void); 66 66 + void* BOMBomMergeIntoBomWithPatternList(void); 67 67 + void* BOMBomNew(void); 68 68 + void* BOMBomNewFromBom(void); 69 69 + void* BOMBomNewFromBomWithOptions(void); 70 70 + void* BOMBomNewFromBomWithStripping(void); 71 71 + void* BOMBomNewFromDirectory(void); 72 72 + void* BOMBomNewFromDirectoryWithSys(void); 73 73 + void* BOMBomNewFromPath(void); 74 74 + void* BOMBomNewFromPathWithSys(void); 75 75 + void* BOMBomNewWithStorage(void); 76 76 + void* BOMBomNewWithSys(void); 77 77 + void* BOMBomOpen(void); 78 78 + void* BOMBomOpenWithStorage(void); 79 79 + void* BOMBomOpenWithSys(void); 80 80 + void* BOMBomPathIDAndArchsForKey(void); 81 81 + void* BOMBomPathIDForKey(void); 82 82 + void* BOMBomPathsTree(void); 83 83 + void* BOMBomRemoveFSObject(void); 84 84 + void* BOMBomSync(void); 85 85 + void* BOMBomVariantAdd(void); 86 86 + void* BOMBomVariantCount(void); 87 87 + void* BOMBomVariantGet(void); 88 88 + void* BOMBomVariantGetList(void); 89 89 + void* BOMBomVariantRemove(void); 90 90 + void* BOMBomVerifyBom(void); 91 91 + void* BOMCFArrayMaxRange(void); 92 92 + void* BOMCFGetBoolValue(void); 93 93 + void* BOMCFPropertyListReadFromPath(void); 94 94 + void* BOMCFPropertyListReadFromPathWithSys(void); 95 95 + void* BOMCFPropertyListWriteToPath(void); 96 96 + void* BOMCFPropertyListWriteToPathWithSys(void); 97 97 + void* BOMCFStringGetUTF8String(void); 98 98 + void* BOMCKTreeBuildKey(void); 99 99 + void* BOMCKTreeCount(void); 100 100 + void* BOMCKTreeGet(void); 101 101 + void* BOMCPIOFree(void); 102 102 + void* BOMCPIOGetFile(void); 103 103 + void* BOMCPIONew(void); 104 104 + void* BOMCPIORead(void); 105 105 + void* BOMCPIOReadHeader(void); 106 106 + void* BOMCPIOSeek(void); 107 107 + void* BOMCPIOWrite(void); 108 108 + void* BOMCPIOWriteDevice(void); 109 109 + void* BOMCPIOWriteDirectory(void); 110 110 + void* BOMCPIOWriteHeader(void); 111 111 + void* BOMCPIOWriteSymlink(void); 112 112 + void* BOMCPIOWriteTerminator(void); 113 113 + void* BOMCRC32ForBuffer(void); 114 114 + void* BOMCRC32ForBufferSegment(void); 115 115 + void* BOMCRC32ForBufferSegmentFinal(void); 116 116 + void* BOMCRC32ForFile(void); 117 117 + void* BOMCRC32ForFileDesc(void); 118 118 + void* BOMCRC32ForFileDescWithSys(void); 119 119 + void* BOMCRC32ForFileWithSys(void); 120 120 + void* BOMCopierCancelCopy(void); 121 121 + void* BOMCopierCopy(void); 122 122 + void* BOMCopierCopyWithOptions(void); 123 123 + void* BOMCopierCountFilesInArchive(void); 124 124 + void* BOMCopierCountFilesInDirectory(void); 125 125 + void* BOMCopierFree(void); 126 126 + void* BOMCopierGetArchiveFileDescriptor(void); 127 127 + void* BOMCopierMultiCopy(void); 128 128 + void* BOMCopierMultiCopyWithOptions(void); 129 129 + void* BOMCopierNew(void); 130 130 + void* BOMCopierNewWithSys(void); 131 131 + void* BOMCopierRedirectPath(void); 132 132 + void* BOMCopierRedirectSourcePath(void); 133 133 + void* BOMCopierSetCopyFileFinishedHandler(void); 134 134 + void* BOMCopierSetCopyFileStartedHandler(void); 135 135 + void* BOMCopierSetCopyFileUpdateHandler(void); 136 136 + void* BOMCopierSetCountFilesUpdateHandler(void); 137 137 + void* BOMCopierSetFatalErrorHandler(void); 138 138 + void* BOMCopierSetFatalFileErrorHandler(void); 139 139 + void* BOMCopierSetFileConflictErrorHandler(void); 140 140 + void* BOMCopierSetFileErrorHandler(void); 141 141 + void* BOMCopierSetMultiCopySourceStartedHandler(void); 142 142 + void* BOMCopierSetPKZipPasswordRequester(void); 143 143 + void* BOMCopierSetUserData(void); 144 144 + void* BOMCopierUserData(void); 145 145 + void* BOMExceptionHandlerMessage(void); 146 146 + void* BOMExceptionHandlerSet(void); 147 147 + void* BOMFSEnumeratorFree(void); 148 148 + void* BOMFSEnumeratorNew(void); 149 149 + void* BOMFSEnumeratorNewWithSys(void); 150 150 + void* BOMFSEnumeratorNext(void); 151 151 + void* BOMFSObjectArchCount(void); 152 152 + void* BOMFSObjectBlockID(void); 153 153 + void* BOMFSObjectChecksum(void); 154 154 + void* BOMFSObjectContainsArchitecture(void); 155 155 + void* BOMFSObjectCopy(void); 156 156 + void* BOMFSObjectDeviceID(void); 157 157 + void* BOMFSObjectENewFromPath(void); 158 158 + void* BOMFSObjectENewFromPathWithSys(void); 159 159 + void* BOMFSObjectFree(void); 160 160 + void* BOMFSObjectGetArch(void); 161 161 + void* BOMFSObjectGetArchSize(void); 162 162 + void* BOMFSObjectGetArchSubtype(void); 163 163 + void* BOMFSObjectGetHardlinkCount(void); 164 164 + void* BOMFSObjectGetHardlinkPath(void); 165 165 + void* BOMFSObjectGroupID(void); 166 166 + void* BOMFSObjectIsBinaryObject(void); 167 167 + void* BOMFSObjectIsHardlink(void); 168 168 + void* BOMFSObjectModTime(void); 169 169 + void* BOMFSObjectMode(void); 170 170 + void* BOMFSObjectNew(void); 171 171 + void* BOMFSObjectNewFromPath(void); 172 172 + void* BOMFSObjectNewFromPathDeferred(void); 173 173 + void* BOMFSObjectNewFromPathDeferredWithSys(void); 174 174 + void* BOMFSObjectNewFromPathString(void); 175 175 + void* BOMFSObjectNewFromPathStringWithSys(void); 176 176 + void* BOMFSObjectNewFromPathWithSys(void); 177 177 + void* BOMFSObjectNewWithSys(void); 178 178 + void* BOMFSObjectOpaqueData(void); 179 179 + void* BOMFSObjectOpaqueDataSize(void); 180 180 + void* BOMFSObjectParentPathID(void); 181 181 + void* BOMFSObjectParseSummary(void); 182 182 + void* BOMFSObjectParseSummaryWithSys(void); 183 183 + void* BOMFSObjectPathID(void); 184 184 + void* BOMFSObjectPathName(void); 185 185 + void* BOMFSObjectPathNameString(void); 186 186 + void* BOMFSObjectSetBlockID(void); 187 187 + void* BOMFSObjectSetChecksum(void); 188 188 + void* BOMFSObjectSetDeviceID(void); 189 189 + void* BOMFSObjectSetFlags(void); 190 190 + void* BOMFSObjectSetGroupID(void); 191 191 + void* BOMFSObjectSetModTime(void); 192 192 + void* BOMFSObjectSetMode(void); 193 193 + void* BOMFSObjectSetOpaqueData(void); 194 194 + void* BOMFSObjectSetParentPathID(void); 195 195 + void* BOMFSObjectSetPathID(void); 196 196 + void* BOMFSObjectSetPathName(void); 197 197 + void* BOMFSObjectSetShortName(void); 198 198 + void* BOMFSObjectSetSize(void); 199 199 + void* BOMFSObjectSetSymlinkTarget(void); 200 200 + void* BOMFSObjectSetUserID(void); 201 201 + void* BOMFSObjectSetVisitOrder(void); 202 202 + void* BOMFSObjectShortName(void); 203 203 + void* BOMFSObjectShortNameString(void); 204 204 + void* BOMFSObjectSize(void); 205 205 + void* BOMFSObjectSummary(void); 206 206 + void* BOMFSObjectSummaryWithFormat(void); 207 207 + void* BOMFSObjectSymlinkTarget(void); 208 208 + void* BOMFSObjectSymlinkTargetString(void); 209 209 + void* BOMFSObjectThinKeepingArchs(void); 210 210 + void* BOMFSObjectType(void); 211 211 + void* BOMFSObjectTypeForMode(void); 212 212 + void* BOMFSObjectTypeFromRawData(void); 213 213 + void* BOMFSObjectUserID(void); 214 214 + void* BOMFSObjectVisitOrder(void); 215 215 + void* BOMFileClose(void); 216 216 + void* BOMFileNewFromFD(void); 217 217 + void* BOMFileNewFromFDWithSys(void); 218 218 + void* BOMFileNewMirror(void); 219 219 + void* BOMFileNewMirrorWithSys(void); 220 220 + void* BOMFileOffset(void); 221 221 + void* BOMFileOpen(void); 222 222 + void* BOMFileOpenSTDIN(void); 223 223 + void* BOMFileOpenSTDOUT(void); 224 224 + void* BOMFileOpenWithSys(void); 225 225 + void* BOMFileRead(void); 226 226 + void* BOMFileSeek(void); 227 227 + void* BOMFileUncompressedOffset(void); 228 228 + void* BOMFileWrite(void); 229 229 + void* BOMFilesystemInfoCreate(void); 230 230 + void* BOMFilesystemInfoDestroy(void); 231 231 + void* BOMFilesystemInfoQuery(void); 232 232 + void* BOMHardLinkTableFree(void); 233 233 + void* BOMHardLinkTableGet(void); 234 234 + void* BOMHardLinkTableGetPathAndData(void); 235 235 + void* BOMHardLinkTableNew(void); 236 236 + void* BOMHardLinkTableSet(void); 237 237 + void* BOMHardLinkTableSetPathAndData(void); 238 238 + void* BOMMemoryDump(void); 239 239 + void* BOMNameForFSObjectType(void); 240 240 + void* BOMPatternCompileString(void); 241 241 + void* BOMPatternFree(void); 242 242 + void* BOMPatternListExtractFromFile(void); 243 243 + void* BOMPatternListExtractFromStrings(void); 244 244 + void* BOMPatternListFree(void); 245 245 + void* BOMPatternListFromStringList(void); 246 246 + void* BOMPatternListMatch(void); 247 247 + void* BOMPatternListNew(void); 248 248 + void* BOMPatternMatch(void); 249 249 + void* BOMStackCount(void); 250 250 + void* BOMStackFree(void); 251 251 + void* BOMStackIsEmpty(void); 252 252 + void* BOMStackNew(void); 253 253 + void* BOMStackPeek(void); 254 254 + void* BOMStackPoke(void); 255 255 + void* BOMStackPop(void); 256 256 + void* BOMStackPush(void); 257 257 + void* BOMStorageCommit(void); 258 258 + void* BOMStorageCompact(void); 259 259 + void* BOMStorageCopyFromBlock(void); 260 260 + void* BOMStorageCopyFromBlockRange(void); 261 261 + void* BOMStorageCopyToBlock(void); 262 262 + void* BOMStorageCopyToBlockRange(void); 263 263 + void* BOMStorageCount(void); 264 264 + void* BOMStorageDump(void); 265 265 + void* BOMStorageDumpFreeList(void); 266 266 + void* BOMStorageFileName(void); 267 267 + void* BOMStorageFindActualFreeSpace(void); 268 268 + void* BOMStorageFree(void); 269 269 + void* BOMStorageFreeBlock(void); 270 270 + void* BOMStorageFreeNamedBlock(void); 271 271 + void* BOMStorageGetNamedBlock(void); 272 272 + void* BOMStorageGetSys(void); 273 273 + void* BOMStorageIsOpenForWriting(void); 274 274 + void* BOMStorageIsStorageFile(void); 275 275 + void* BOMStorageIsStorageFileWithSys(void); 276 276 + void* BOMStorageNew(void); 277 277 + void* BOMStorageNewBlock(void); 278 278 + void* BOMStorageNewInRAM(void); 279 279 + void* BOMStorageNewNamedBlock(void); 280 280 + void* BOMStorageNewWithOptions(void); 281 281 + void* BOMStorageNewWithOptionsAndSys(void); 282 282 + void* BOMStorageNewWithSys(void); 283 283 + void* BOMStorageOpen(void); 284 284 + void* BOMStorageOpenInRAM(void); 285 285 + void* BOMStorageOpenWithSys(void); 286 286 + void* BOMStorageSetBlockData(void); 287 287 + void* BOMStorageSizeOfBlock(void); 288 288 + void* BOMStreamFlush(void); 289 289 + void* BOMStreamFree(void); 290 290 + void* BOMStreamGetByteOrder(void); 291 291 + void* BOMStreamGetSys(void); 292 292 + void* BOMStreamReadAddress(void); 293 293 + void* BOMStreamReadBuffer(void); 294 294 + void* BOMStreamReadUInt16(void); 295 295 + void* BOMStreamReadUInt32(void); 296 296 + void* BOMStreamReadUInt8(void); 297 297 + void* BOMStreamSetByteOrder(void); 298 298 + void* BOMStreamWithAddress(void); 299 299 + void* BOMStreamWithBlockID(void); 300 300 + void* BOMStreamWithFile(void); 301 301 + void* BOMStreamWithFileAndSys(void); 302 302 + void* BOMStreamWriteBuffer(void); 303 303 + void* BOMStreamWriteUInt16(void); 304 304 + void* BOMStreamWriteUInt32(void); 305 305 + void* BOMStreamWriteUInt8(void); 306 306 + void* BOMTreeCommit(void); 307 307 + void* BOMTreeCopyToTree(void); 308 308 + void* BOMTreeCount(void); 309 309 + void* BOMTreeFree(void); 310 310 + void* BOMTreeGetValue(void); 311 311 + void* BOMTreeGetValueSize(void); 312 312 + void* BOMTreeIteratorFree(void); 313 313 + void* BOMTreeIteratorIsAtEnd(void); 314 314 + void* BOMTreeIteratorKey(void); 315 315 + void* BOMTreeIteratorKeySize(void); 316 316 + void* BOMTreeIteratorNew(void); 317 317 + void* BOMTreeIteratorNext(void); 318 318 + void* BOMTreeIteratorSet(void); 319 319 + void* BOMTreeIteratorValue(void); 320 320 + void* BOMTreeIteratorValueSize(void); 321 321 + void* BOMTreeNew(void); 322 322 + void* BOMTreeNewWithName(void); 323 323 + void* BOMTreeNewWithOptions(void); 324 324 + void* BOMTreeOpen(void); 325 325 + void* BOMTreeOpenWithName(void); 326 326 + void* BOMTreeRemoveAndFree(void); 327 327 + void* BOMTreeRemoveValue(void); 328 328 + void* BOMTreeSetCompareFunc(void); 329 329 + void* BOMTreeSetValue(void); 330 330 + void* BOMTreeStorage(void); 331 331 + void* BOM_calloc(void); 332 332 + void* BOM_malloc(void); 333 333 + void* BOM_malloczero(void); 334 334 + void* BOM_realloc(void); 335 335 + void* BOM_realloczero(void); 336 336 + void* BOM_strrncmp(void); 337 337 + void* BomSys_access(void); 338 338 + void* BomSys_chdir(void); 339 339 + void* BomSys_chflags(void); 340 340 + void* BomSys_chmod(void); 341 341 + void* BomSys_close(void); 342 342 + void* BomSys_closedir(void); 343 343 + void* BomSys_default(void); 344 344 + void* BomSys_fcntl(void); 345 345 + void* BomSys_free(void); 346 346 + void* BomSys_fstat(void); 347 347 + void* BomSys_fstatfs(void); 348 348 + void* BomSys_fsync(void); 349 349 + void* BomSys_getattrlist(void); 350 350 + void* BomSys_getcwd(void); 351 351 + void* BomSys_getxattr(void); 352 352 + void* BomSys_init(void); 353 353 + void* BomSys_lchown(void); 354 354 + void* BomSys_link(void); 355 355 + void* BomSys_listxattr(void); 356 356 + void* BomSys_log_attach(void); 357 357 + void* BomSys_log_attached(void); 358 358 + void* BomSys_log_config(void); 359 359 + void* BomSys_log_detach(void); 360 360 + void* BomSys_log_pause(void); 361 361 + void* BomSys_log_resume(void); 362 362 + void* BomSys_lseek(void); 363 363 + void* BomSys_lstat(void); 364 364 + void* BomSys_mkdir(void); 365 365 + void* BomSys_mknod(void); 366 366 + void* BomSys_mktemp(void); 367 367 + void* BomSys_mmap(void); 368 368 + void* BomSys_munmap(void); 369 369 + void* BomSys_open(void); 370 370 + void* BomSys_openFor(void); 371 371 + void* BomSys_opendir(void); 372 372 + void* BomSys_read(void); 373 373 + void* BomSys_readdir(void); 374 374 + void* BomSys_readdir_r(void); 375 375 + void* BomSys_readlink(void); 376 376 + void* BomSys_realpath(void); 377 377 + void* BomSys_removexattr(void); 378 378 + void* BomSys_rename(void); 379 379 + void* BomSys_rmdir(void); 380 380 + void* BomSys_set_access(void); 381 381 + void* BomSys_set_chdir(void); 382 382 + void* BomSys_set_chflags(void); 383 383 + void* BomSys_set_chmod(void); 384 384 + void* BomSys_set_close(void); 385 385 + void* BomSys_set_closedir(void); 386 386 + void* BomSys_set_fcntl(void); 387 387 + void* BomSys_set_fstat(void); 388 388 + void* BomSys_set_fstatfs(void); 389 389 + void* BomSys_set_fsync(void); 390 390 + void* BomSys_set_getattrlist(void); 391 391 + void* BomSys_set_getcwd(void); 392 392 + void* BomSys_set_getxattr(void); 393 393 + void* BomSys_set_lchown(void); 394 394 + void* BomSys_set_link(void); 395 395 + void* BomSys_set_listxattr(void); 396 396 + void* BomSys_set_lseek(void); 397 397 + void* BomSys_set_lstat(void); 398 398 + void* BomSys_set_mkdir(void); 399 399 + void* BomSys_set_mknod(void); 400 400 + void* BomSys_set_mktemp(void); 401 401 + void* BomSys_set_mmap(void); 402 402 + void* BomSys_set_munmap(void); 403 403 + void* BomSys_set_open(void); 404 404 + void* BomSys_set_openFor(void); 405 405 + void* BomSys_set_opendir(void); 406 406 + void* BomSys_set_read(void); 407 407 + void* BomSys_set_readdir(void); 408 408 + void* BomSys_set_readdir_r(void); 409 409 + void* BomSys_set_readlink(void); 410 410 + void* BomSys_set_realpath(void); 411 411 + void* BomSys_set_removexattr(void); 412 412 + void* BomSys_set_rename(void); 413 413 + void* BomSys_set_rmdir(void); 414 414 + void* BomSys_set_setxattr(void); 415 415 + void* BomSys_set_stat(void); 416 416 + void* BomSys_set_statfs(void); 417 417 + void* BomSys_set_symlink(void); 418 418 + void* BomSys_set_unlink(void); 419 419 + void* BomSys_set_utimes(void); 420 420 + void* BomSys_set_write(void); 421 421 + void* BomSys_setxattr(void); 422 422 + void* BomSys_stat(void); 423 423 + void* BomSys_statfs(void); 424 424 + void* BomSys_symlink(void); 425 425 + void* BomSys_unlink(void); 426 426 + void* BomSys_utimes(void); 427 427 + void* BomSys_write(void); 428 428 + void* _BOMBomPathTreePrint(void); 429 429 + void* _BOMBomPrint(void); 430 430 + void* _BOMCFArrayPrint(void); 431 431 + void* _BOMExceptionHandlerCall(void); 432 432 + void* _BOMFatalException(void); 433 433 + 434 434 + #endif

+2484

src/frameworks/Bom/src/Bom.c

reviewed

··· 1 1 + /* 2 2 + This file is part of Darling. 3 3 + 4 4 + Copyright (C) 2019 Lubos Dolezel 5 5 + 6 6 + Darling is free software: you can redistribute it and/or modify 7 7 + it under the terms of the GNU General Public License as published by 8 8 + the Free Software Foundation, either version 3 of the License, or 9 9 + (at your option) any later version. 10 10 + 11 11 + Darling is distributed in the hope that it will be useful, 12 12 + but WITHOUT ANY WARRANTY; without even the implied warranty of 13 13 + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 14 + GNU General Public License for more details. 15 15 + 16 16 + You should have received a copy of the GNU General Public License 17 17 + along with Darling. If not, see <http://www.gnu.org/licenses/>. 18 18 + */ 19 19 + 20 20 + 21 21 + #include <Bom/Bom.h> 22 22 + #include <stdlib.h> 23 23 + #include <stdio.h> 24 24 + 25 25 + static int verbose = 0; 26 26 + 27 27 + __attribute__((constructor)) 28 28 + static void initme(void) { 29 29 + verbose = getenv("STUB_VERBOSE") != NULL; 30 30 + } 31 31 + 32 32 + void* BOMAppleDoubleADPathToPath(void) 33 33 + { 34 34 + if (verbose) puts("STUB: BOMAppleDoubleADPathToPath called"); 35 35 + return NULL; 36 36 + } 37 37 + 38 38 + void* BOMAppleDoubleCopyHeader(void) 39 39 + { 40 40 + if (verbose) puts("STUB: BOMAppleDoubleCopyHeader called"); 41 41 + return NULL; 42 42 + } 43 43 + 44 44 + void* BOMAppleDoubleIsADFile(void) 45 45 + { 46 46 + if (verbose) puts("STUB: BOMAppleDoubleIsADFile called"); 47 47 + return NULL; 48 48 + } 49 49 + 50 50 + void* BOMAppleDoublePathToADPath(void) 51 51 + { 52 52 + if (verbose) puts("STUB: BOMAppleDoublePathToADPath called"); 53 53 + return NULL; 54 54 + } 55 55 + 56 56 + void* BOMAppleDoubleReadHeader(void) 57 57 + { 58 58 + if (verbose) puts("STUB: BOMAppleDoubleReadHeader called"); 59 59 + return NULL; 60 60 + } 61 61 + 62 62 + void* BOMAppleDoubleSize(void) 63 63 + { 64 64 + if (verbose) puts("STUB: BOMAppleDoubleSize called"); 65 65 + return NULL; 66 66 + } 67 67 + 68 68 + void* BOMAppleDoubleWriteHeader(void) 69 69 + { 70 70 + if (verbose) puts("STUB: BOMAppleDoubleWriteHeader called"); 71 71 + return NULL; 72 72 + } 73 73 + 74 74 + void* BOMArchFlagForFile(void) 75 75 + { 76 76 + if (verbose) puts("STUB: BOMArchFlagForFile called"); 77 77 + return NULL; 78 78 + } 79 79 + 80 80 + void* BOMArchFlagForFileWithSys(void) 81 81 + { 82 82 + if (verbose) puts("STUB: BOMArchFlagForFileWithSys called"); 83 83 + return NULL; 84 84 + } 85 85 + 86 86 + void* BOMArchFlagForHeader(void) 87 87 + { 88 88 + if (verbose) puts("STUB: BOMArchFlagForHeader called"); 89 89 + return NULL; 90 90 + } 91 91 + 92 92 + void* BOMBomApproximateBytesRepresented(void) 93 93 + { 94 94 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresented called"); 95 95 + return NULL; 96 96 + } 97 97 + 98 98 + void* BOMBomApproximateBytesRepresented64(void) 99 99 + { 100 100 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresented64 called"); 101 101 + return NULL; 102 102 + } 103 103 + 104 104 + void* BOMBomApproximateBytesRepresentedByVariant(void) 105 105 + { 106 106 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedByVariant called"); 107 107 + return NULL; 108 108 + } 109 109 + 110 110 + void* BOMBomApproximateBytesRepresentedByVariant64(void) 111 111 + { 112 112 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedByVariant64 called"); 113 113 + return NULL; 114 114 + } 115 115 + 116 116 + void* BOMBomApproximateBytesRepresentedByVariantIsValid(void) 117 117 + { 118 118 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedByVariantIsValid called"); 119 119 + return NULL; 120 120 + } 121 121 + 122 122 + void* BOMBomApproximateBytesRepresentedByVariantWithBlockSize(void) 123 123 + { 124 124 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedByVariantWithBlockSize called"); 125 125 + return NULL; 126 126 + } 127 127 + 128 128 + void* BOMBomApproximateBytesRepresentedByVariantWithBlockSize64(void) 129 129 + { 130 130 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedByVariantWithBlockSize64 called"); 131 131 + return NULL; 132 132 + } 133 133 + 134 134 + void* BOMBomApproximateBytesRepresentedWithBlockSize(void) 135 135 + { 136 136 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedWithBlockSize called"); 137 137 + return NULL; 138 138 + } 139 139 + 140 140 + void* BOMBomApproximateBytesRepresentedWithBlockSize64(void) 141 141 + { 142 142 + if (verbose) puts("STUB: BOMBomApproximateBytesRepresentedWithBlockSize64 called"); 143 143 + return NULL; 144 144 + } 145 145 + 146 146 + void* BOMBomCommit(void) 147 147 + { 148 148 + if (verbose) puts("STUB: BOMBomCommit called"); 149 149 + return NULL; 150 150 + } 151 151 + 152 152 + void* BOMBomDumpLinks(void) 153 153 + { 154 154 + if (verbose) puts("STUB: BOMBomDumpLinks called"); 155 155 + return NULL; 156 156 + } 157 157 + 158 158 + void* BOMBomEInsertFSObject(void) 159 159 + { 160 160 + if (verbose) puts("STUB: BOMBomEInsertFSObject called"); 161 161 + return NULL; 162 162 + } 163 163 + 164 164 + void* BOMBomEInvalidateCachedData(void) 165 165 + { 166 166 + if (verbose) puts("STUB: BOMBomEInvalidateCachedData called"); 167 167 + return NULL; 168 168 + } 169 169 + 170 170 + void* BOMBomELinkFromPathToPath(void) 171 171 + { 172 172 + if (verbose) puts("STUB: BOMBomELinkFromPathToPath called"); 173 173 + return NULL; 174 174 + } 175 175 + 176 176 + void* BOMBomEnumeratorFree(void) 177 177 + { 178 178 + if (verbose) puts("STUB: BOMBomEnumeratorFree called"); 179 179 + return NULL; 180 180 + } 181 181 + 182 182 + void* BOMBomEnumeratorNew(void) 183 183 + { 184 184 + if (verbose) puts("STUB: BOMBomEnumeratorNew called"); 185 185 + return NULL; 186 186 + } 187 187 + 188 188 + void* BOMBomEnumeratorNewWithOptions(void) 189 189 + { 190 190 + if (verbose) puts("STUB: BOMBomEnumeratorNewWithOptions called"); 191 191 + return NULL; 192 192 + } 193 193 + 194 194 + void* BOMBomEnumeratorNext(void) 195 195 + { 196 196 + if (verbose) puts("STUB: BOMBomEnumeratorNext called"); 197 197 + return NULL; 198 198 + } 199 199 + 200 200 + void* BOMBomEnumeratorSkip(void) 201 201 + { 202 202 + if (verbose) puts("STUB: BOMBomEnumeratorSkip called"); 203 203 + return NULL; 204 204 + } 205 205 + 206 206 + void* BOMBomEnumeratorSkipAll(void) 207 207 + { 208 208 + if (verbose) puts("STUB: BOMBomEnumeratorSkipAll called"); 209 209 + return NULL; 210 210 + } 211 211 + 212 212 + void* BOMBomFSObjectCount(void) 213 213 + { 214 214 + if (verbose) puts("STUB: BOMBomFSObjectCount called"); 215 215 + return NULL; 216 216 + } 217 217 + 218 218 + void* BOMBomFSObjectExistsAtPath(void) 219 219 + { 220 220 + if (verbose) puts("STUB: BOMBomFSObjectExistsAtPath called"); 221 221 + return NULL; 222 222 + } 223 223 + 224 224 + void* BOMBomFree(void) 225 225 + { 226 226 + if (verbose) puts("STUB: BOMBomFree called"); 227 227 + return NULL; 228 228 + } 229 229 + 230 230 + void* BOMBomGetFSObjectAtPath(void) 231 231 + { 232 232 + if (verbose) puts("STUB: BOMBomGetFSObjectAtPath called"); 233 233 + return NULL; 234 234 + } 235 235 + 236 236 + void* BOMBomGetRootFSObject(void) 237 237 + { 238 238 + if (verbose) puts("STUB: BOMBomGetRootFSObject called"); 239 239 + return NULL; 240 240 + } 241 241 + 242 242 + void* BOMBomInsertFSObject(void) 243 243 + { 244 244 + if (verbose) puts("STUB: BOMBomInsertFSObject called"); 245 245 + return NULL; 246 246 + } 247 247 + 248 248 + void* BOMBomLinkToFSObjectFromPath(void) 249 249 + { 250 250 + if (verbose) puts("STUB: BOMBomLinkToFSObjectFromPath called"); 251 251 + return NULL; 252 252 + } 253 253 + 254 254 + void* BOMBomLinkToPathFromPath(void) 255 255 + { 256 256 + if (verbose) puts("STUB: BOMBomLinkToPathFromPath called"); 257 257 + return NULL; 258 258 + } 259 259 + 260 260 + void* BOMBomMaskWithBom(void) 261 261 + { 262 262 + if (verbose) puts("STUB: BOMBomMaskWithBom called"); 263 263 + return NULL; 264 264 + } 265 265 + 266 266 + void* BOMBomMaskWithPatternList(void) 267 267 + { 268 268 + if (verbose) puts("STUB: BOMBomMaskWithPatternList called"); 269 269 + return NULL; 270 270 + } 271 271 + 272 272 + void* BOMBomMergeInto(void) 273 273 + { 274 274 + if (verbose) puts("STUB: BOMBomMergeInto called"); 275 275 + return NULL; 276 276 + } 277 277 + 278 278 + void* BOMBomMergeIntoBom(void) 279 279 + { 280 280 + if (verbose) puts("STUB: BOMBomMergeIntoBom called"); 281 281 + return NULL; 282 282 + } 283 283 + 284 284 + void* BOMBomMergeIntoBomWithPatternList(void) 285 285 + { 286 286 + if (verbose) puts("STUB: BOMBomMergeIntoBomWithPatternList called"); 287 287 + return NULL; 288 288 + } 289 289 + 290 290 + void* BOMBomNew(void) 291 291 + { 292 292 + if (verbose) puts("STUB: BOMBomNew called"); 293 293 + return NULL; 294 294 + } 295 295 + 296 296 + void* BOMBomNewFromBom(void) 297 297 + { 298 298 + if (verbose) puts("STUB: BOMBomNewFromBom called"); 299 299 + return NULL; 300 300 + } 301 301 + 302 302 + void* BOMBomNewFromBomWithOptions(void) 303 303 + { 304 304 + if (verbose) puts("STUB: BOMBomNewFromBomWithOptions called"); 305 305 + return NULL; 306 306 + } 307 307 + 308 308 + void* BOMBomNewFromBomWithStripping(void) 309 309 + { 310 310 + if (verbose) puts("STUB: BOMBomNewFromBomWithStripping called"); 311 311 + return NULL; 312 312 + } 313 313 + 314 314 + void* BOMBomNewFromDirectory(void) 315 315 + { 316 316 + if (verbose) puts("STUB: BOMBomNewFromDirectory called"); 317 317 + return NULL; 318 318 + } 319 319 + 320 320 + void* BOMBomNewFromDirectoryWithSys(void) 321 321 + { 322 322 + if (verbose) puts("STUB: BOMBomNewFromDirectoryWithSys called"); 323 323 + return NULL; 324 324 + } 325 325 + 326 326 + void* BOMBomNewFromPath(void) 327 327 + { 328 328 + if (verbose) puts("STUB: BOMBomNewFromPath called"); 329 329 + return NULL; 330 330 + } 331 331 + 332 332 + void* BOMBomNewFromPathWithSys(void) 333 333 + { 334 334 + if (verbose) puts("STUB: BOMBomNewFromPathWithSys called"); 335 335 + return NULL; 336 336 + } 337 337 + 338 338 + void* BOMBomNewWithStorage(void) 339 339 + { 340 340 + if (verbose) puts("STUB: BOMBomNewWithStorage called"); 341 341 + return NULL; 342 342 + } 343 343 + 344 344 + void* BOMBomNewWithSys(void) 345 345 + { 346 346 + if (verbose) puts("STUB: BOMBomNewWithSys called"); 347 347 + return NULL; 348 348 + } 349 349 + 350 350 + void* BOMBomOpen(void) 351 351 + { 352 352 + if (verbose) puts("STUB: BOMBomOpen called"); 353 353 + return NULL; 354 354 + } 355 355 + 356 356 + void* BOMBomOpenWithStorage(void) 357 357 + { 358 358 + if (verbose) puts("STUB: BOMBomOpenWithStorage called"); 359 359 + return NULL; 360 360 + } 361 361 + 362 362 + void* BOMBomOpenWithSys(void) 363 363 + { 364 364 + if (verbose) puts("STUB: BOMBomOpenWithSys called"); 365 365 + return NULL; 366 366 + } 367 367 + 368 368 + void* BOMBomPathIDAndArchsForKey(void) 369 369 + { 370 370 + if (verbose) puts("STUB: BOMBomPathIDAndArchsForKey called"); 371 371 + return NULL; 372 372 + } 373 373 + 374 374 + void* BOMBomPathIDForKey(void) 375 375 + { 376 376 + if (verbose) puts("STUB: BOMBomPathIDForKey called"); 377 377 + return NULL; 378 378 + } 379 379 + 380 380 + void* BOMBomPathsTree(void) 381 381 + { 382 382 + if (verbose) puts("STUB: BOMBomPathsTree called"); 383 383 + return NULL; 384 384 + } 385 385 + 386 386 + void* BOMBomRemoveFSObject(void) 387 387 + { 388 388 + if (verbose) puts("STUB: BOMBomRemoveFSObject called"); 389 389 + return NULL; 390 390 + } 391 391 + 392 392 + void* BOMBomSync(void) 393 393 + { 394 394 + if (verbose) puts("STUB: BOMBomSync called"); 395 395 + return NULL; 396 396 + } 397 397 + 398 398 + void* BOMBomVariantAdd(void) 399 399 + { 400 400 + if (verbose) puts("STUB: BOMBomVariantAdd called"); 401 401 + return NULL; 402 402 + } 403 403 + 404 404 + void* BOMBomVariantCount(void) 405 405 + { 406 406 + if (verbose) puts("STUB: BOMBomVariantCount called"); 407 407 + return NULL; 408 408 + } 409 409 + 410 410 + void* BOMBomVariantGet(void) 411 411 + { 412 412 + if (verbose) puts("STUB: BOMBomVariantGet called"); 413 413 + return NULL; 414 414 + } 415 415 + 416 416 + void* BOMBomVariantGetList(void) 417 417 + { 418 418 + if (verbose) puts("STUB: BOMBomVariantGetList called"); 419 419 + return NULL; 420 420 + } 421 421 + 422 422 + void* BOMBomVariantRemove(void) 423 423 + { 424 424 + if (verbose) puts("STUB: BOMBomVariantRemove called"); 425 425 + return NULL; 426 426 + } 427 427 + 428 428 + void* BOMBomVerifyBom(void) 429 429 + { 430 430 + if (verbose) puts("STUB: BOMBomVerifyBom called"); 431 431 + return NULL; 432 432 + } 433 433 + 434 434 + void* BOMCFArrayMaxRange(void) 435 435 + { 436 436 + if (verbose) puts("STUB: BOMCFArrayMaxRange called"); 437 437 + return NULL; 438 438 + } 439 439 + 440 440 + void* BOMCFGetBoolValue(void) 441 441 + { 442 442 + if (verbose) puts("STUB: BOMCFGetBoolValue called"); 443 443 + return NULL; 444 444 + } 445 445 + 446 446 + void* BOMCFPropertyListReadFromPath(void) 447 447 + { 448 448 + if (verbose) puts("STUB: BOMCFPropertyListReadFromPath called"); 449 449 + return NULL; 450 450 + } 451 451 + 452 452 + void* BOMCFPropertyListReadFromPathWithSys(void) 453 453 + { 454 454 + if (verbose) puts("STUB: BOMCFPropertyListReadFromPathWithSys called"); 455 455 + return NULL; 456 456 + } 457 457 + 458 458 + void* BOMCFPropertyListWriteToPath(void) 459 459 + { 460 460 + if (verbose) puts("STUB: BOMCFPropertyListWriteToPath called"); 461 461 + return NULL; 462 462 + } 463 463 + 464 464 + void* BOMCFPropertyListWriteToPathWithSys(void) 465 465 + { 466 466 + if (verbose) puts("STUB: BOMCFPropertyListWriteToPathWithSys called"); 467 467 + return NULL; 468 468 + } 469 469 + 470 470 + void* BOMCFStringGetUTF8String(void) 471 471 + { 472 472 + if (verbose) puts("STUB: BOMCFStringGetUTF8String called"); 473 473 + return NULL; 474 474 + } 475 475 + 476 476 + void* BOMCKTreeBuildKey(void) 477 477 + { 478 478 + if (verbose) puts("STUB: BOMCKTreeBuildKey called"); 479 479 + return NULL; 480 480 + } 481 481 + 482 482 + void* BOMCKTreeCount(void) 483 483 + { 484 484 + if (verbose) puts("STUB: BOMCKTreeCount called"); 485 485 + return NULL; 486 486 + } 487 487 + 488 488 + void* BOMCKTreeGet(void) 489 489 + { 490 490 + if (verbose) puts("STUB: BOMCKTreeGet called"); 491 491 + return NULL; 492 492 + } 493 493 + 494 494 + void* BOMCPIOFree(void) 495 495 + { 496 496 + if (verbose) puts("STUB: BOMCPIOFree called"); 497 497 + return NULL; 498 498 + } 499 499 + 500 500 + void* BOMCPIOGetFile(void) 501 501 + { 502 502 + if (verbose) puts("STUB: BOMCPIOGetFile called"); 503 503 + return NULL; 504 504 + } 505 505 + 506 506 + void* BOMCPIONew(void) 507 507 + { 508 508 + if (verbose) puts("STUB: BOMCPIONew called"); 509 509 + return NULL; 510 510 + } 511 511 + 512 512 + void* BOMCPIORead(void) 513 513 + { 514 514 + if (verbose) puts("STUB: BOMCPIORead called"); 515 515 + return NULL; 516 516 + } 517 517 + 518 518 + void* BOMCPIOReadHeader(void) 519 519 + { 520 520 + if (verbose) puts("STUB: BOMCPIOReadHeader called"); 521 521 + return NULL; 522 522 + } 523 523 + 524 524 + void* BOMCPIOSeek(void) 525 525 + { 526 526 + if (verbose) puts("STUB: BOMCPIOSeek called"); 527 527 + return NULL; 528 528 + } 529 529 + 530 530 + void* BOMCPIOWrite(void) 531 531 + { 532 532 + if (verbose) puts("STUB: BOMCPIOWrite called"); 533 533 + return NULL; 534 534 + } 535 535 + 536 536 + void* BOMCPIOWriteDevice(void) 537 537 + { 538 538 + if (verbose) puts("STUB: BOMCPIOWriteDevice called"); 539 539 + return NULL; 540 540 + } 541 541 + 542 542 + void* BOMCPIOWriteDirectory(void) 543 543 + { 544 544 + if (verbose) puts("STUB: BOMCPIOWriteDirectory called"); 545 545 + return NULL; 546 546 + } 547 547 + 548 548 + void* BOMCPIOWriteHeader(void) 549 549 + { 550 550 + if (verbose) puts("STUB: BOMCPIOWriteHeader called"); 551 551 + return NULL; 552 552 + } 553 553 + 554 554 + void* BOMCPIOWriteSymlink(void) 555 555 + { 556 556 + if (verbose) puts("STUB: BOMCPIOWriteSymlink called"); 557 557 + return NULL; 558 558 + } 559 559 + 560 560 + void* BOMCPIOWriteTerminator(void) 561 561 + { 562 562 + if (verbose) puts("STUB: BOMCPIOWriteTerminator called"); 563 563 + return NULL; 564 564 + } 565 565 + 566 566 + void* BOMCRC32ForBuffer(void) 567 567 + { 568 568 + if (verbose) puts("STUB: BOMCRC32ForBuffer called"); 569 569 + return NULL; 570 570 + } 571 571 + 572 572 + void* BOMCRC32ForBufferSegment(void) 573 573 + { 574 574 + if (verbose) puts("STUB: BOMCRC32ForBufferSegment called"); 575 575 + return NULL; 576 576 + } 577 577 + 578 578 + void* BOMCRC32ForBufferSegmentFinal(void) 579 579 + { 580 580 + if (verbose) puts("STUB: BOMCRC32ForBufferSegmentFinal called"); 581 581 + return NULL; 582 582 + } 583 583 + 584 584 + void* BOMCRC32ForFile(void) 585 585 + { 586 586 + if (verbose) puts("STUB: BOMCRC32ForFile called"); 587 587 + return NULL; 588 588 + } 589 589 + 590 590 + void* BOMCRC32ForFileDesc(void) 591 591 + { 592 592 + if (verbose) puts("STUB: BOMCRC32ForFileDesc called"); 593 593 + return NULL; 594 594 + } 595 595 + 596 596 + void* BOMCRC32ForFileDescWithSys(void) 597 597 + { 598 598 + if (verbose) puts("STUB: BOMCRC32ForFileDescWithSys called"); 599 599 + return NULL; 600 600 + } 601 601 + 602 602 + void* BOMCRC32ForFileWithSys(void) 603 603 + { 604 604 + if (verbose) puts("STUB: BOMCRC32ForFileWithSys called"); 605 605 + return NULL; 606 606 + } 607 607 + 608 608 + void* BOMCopierCancelCopy(void) 609 609 + { 610 610 + if (verbose) puts("STUB: BOMCopierCancelCopy called"); 611 611 + return NULL; 612 612 + } 613 613 + 614 614 + void* BOMCopierCopy(void) 615 615 + { 616 616 + if (verbose) puts("STUB: BOMCopierCopy called"); 617 617 + return NULL; 618 618 + } 619 619 + 620 620 + void* BOMCopierCopyWithOptions(void) 621 621 + { 622 622 + if (verbose) puts("STUB: BOMCopierCopyWithOptions called"); 623 623 + return NULL; 624 624 + } 625 625 + 626 626 + void* BOMCopierCountFilesInArchive(void) 627 627 + { 628 628 + if (verbose) puts("STUB: BOMCopierCountFilesInArchive called"); 629 629 + return NULL; 630 630 + } 631 631 + 632 632 + void* BOMCopierCountFilesInDirectory(void) 633 633 + { 634 634 + if (verbose) puts("STUB: BOMCopierCountFilesInDirectory called"); 635 635 + return NULL; 636 636 + } 637 637 + 638 638 + void* BOMCopierFree(void) 639 639 + { 640 640 + if (verbose) puts("STUB: BOMCopierFree called"); 641 641 + return NULL; 642 642 + } 643 643 + 644 644 + void* BOMCopierGetArchiveFileDescriptor(void) 645 645 + { 646 646 + if (verbose) puts("STUB: BOMCopierGetArchiveFileDescriptor called"); 647 647 + return NULL; 648 648 + } 649 649 + 650 650 + void* BOMCopierMultiCopy(void) 651 651 + { 652 652 + if (verbose) puts("STUB: BOMCopierMultiCopy called"); 653 653 + return NULL; 654 654 + } 655 655 + 656 656 + void* BOMCopierMultiCopyWithOptions(void) 657 657 + { 658 658 + if (verbose) puts("STUB: BOMCopierMultiCopyWithOptions called"); 659 659 + return NULL; 660 660 + } 661 661 + 662 662 + void* BOMCopierNew(void) 663 663 + { 664 664 + if (verbose) puts("STUB: BOMCopierNew called"); 665 665 + return NULL; 666 666 + } 667 667 + 668 668 + void* BOMCopierNewWithSys(void) 669 669 + { 670 670 + if (verbose) puts("STUB: BOMCopierNewWithSys called"); 671 671 + return NULL; 672 672 + } 673 673 + 674 674 + void* BOMCopierRedirectPath(void) 675 675 + { 676 676 + if (verbose) puts("STUB: BOMCopierRedirectPath called"); 677 677 + return NULL; 678 678 + } 679 679 + 680 680 + void* BOMCopierRedirectSourcePath(void) 681 681 + { 682 682 + if (verbose) puts("STUB: BOMCopierRedirectSourcePath called"); 683 683 + return NULL; 684 684 + } 685 685 + 686 686 + void* BOMCopierSetCopyFileFinishedHandler(void) 687 687 + { 688 688 + if (verbose) puts("STUB: BOMCopierSetCopyFileFinishedHandler called"); 689 689 + return NULL; 690 690 + } 691 691 + 692 692 + void* BOMCopierSetCopyFileStartedHandler(void) 693 693 + { 694 694 + if (verbose) puts("STUB: BOMCopierSetCopyFileStartedHandler called"); 695 695 + return NULL; 696 696 + } 697 697 + 698 698 + void* BOMCopierSetCopyFileUpdateHandler(void) 699 699 + { 700 700 + if (verbose) puts("STUB: BOMCopierSetCopyFileUpdateHandler called"); 701 701 + return NULL; 702 702 + } 703 703 + 704 704 + void* BOMCopierSetCountFilesUpdateHandler(void) 705 705 + { 706 706 + if (verbose) puts("STUB: BOMCopierSetCountFilesUpdateHandler called"); 707 707 + return NULL; 708 708 + } 709 709 + 710 710 + void* BOMCopierSetFatalErrorHandler(void) 711 711 + { 712 712 + if (verbose) puts("STUB: BOMCopierSetFatalErrorHandler called"); 713 713 + return NULL; 714 714 + } 715 715 + 716 716 + void* BOMCopierSetFatalFileErrorHandler(void) 717 717 + { 718 718 + if (verbose) puts("STUB: BOMCopierSetFatalFileErrorHandler called"); 719 719 + return NULL; 720 720 + } 721 721 + 722 722 + void* BOMCopierSetFileConflictErrorHandler(void) 723 723 + { 724 724 + if (verbose) puts("STUB: BOMCopierSetFileConflictErrorHandler called"); 725 725 + return NULL; 726 726 + } 727 727 + 728 728 + void* BOMCopierSetFileErrorHandler(void) 729 729 + { 730 730 + if (verbose) puts("STUB: BOMCopierSetFileErrorHandler called"); 731 731 + return NULL; 732 732 + } 733 733 + 734 734 + void* BOMCopierSetMultiCopySourceStartedHandler(void) 735 735 + { 736 736 + if (verbose) puts("STUB: BOMCopierSetMultiCopySourceStartedHandler called"); 737 737 + return NULL; 738 738 + } 739 739 + 740 740 + void* BOMCopierSetPKZipPasswordRequester(void) 741 741 + { 742 742 + if (verbose) puts("STUB: BOMCopierSetPKZipPasswordRequester called"); 743 743 + return NULL; 744 744 + } 745 745 + 746 746 + void* BOMCopierSetUserData(void) 747 747 + { 748 748 + if (verbose) puts("STUB: BOMCopierSetUserData called"); 749 749 + return NULL; 750 750 + } 751 751 + 752 752 + void* BOMCopierUserData(void) 753 753 + { 754 754 + if (verbose) puts("STUB: BOMCopierUserData called"); 755 755 + return NULL; 756 756 + } 757 757 + 758 758 + void* BOMExceptionHandlerMessage(void) 759 759 + { 760 760 + if (verbose) puts("STUB: BOMExceptionHandlerMessage called"); 761 761 + return NULL; 762 762 + } 763 763 + 764 764 + void* BOMExceptionHandlerSet(void) 765 765 + { 766 766 + if (verbose) puts("STUB: BOMExceptionHandlerSet called"); 767 767 + return NULL; 768 768 + } 769 769 + 770 770 + void* BOMFSEnumeratorFree(void) 771 771 + { 772 772 + if (verbose) puts("STUB: BOMFSEnumeratorFree called"); 773 773 + return NULL; 774 774 + } 775 775 + 776 776 + void* BOMFSEnumeratorNew(void) 777 777 + { 778 778 + if (verbose) puts("STUB: BOMFSEnumeratorNew called"); 779 779 + return NULL; 780 780 + } 781 781 + 782 782 + void* BOMFSEnumeratorNewWithSys(void) 783 783 + { 784 784 + if (verbose) puts("STUB: BOMFSEnumeratorNewWithSys called"); 785 785 + return NULL; 786 786 + } 787 787 + 788 788 + void* BOMFSEnumeratorNext(void) 789 789 + { 790 790 + if (verbose) puts("STUB: BOMFSEnumeratorNext called"); 791 791 + return NULL; 792 792 + } 793 793 + 794 794 + void* BOMFSObjectArchCount(void) 795 795 + { 796 796 + if (verbose) puts("STUB: BOMFSObjectArchCount called"); 797 797 + return NULL; 798 798 + } 799 799 + 800 800 + void* BOMFSObjectBlockID(void) 801 801 + { 802 802 + if (verbose) puts("STUB: BOMFSObjectBlockID called"); 803 803 + return NULL; 804 804 + } 805 805 + 806 806 + void* BOMFSObjectChecksum(void) 807 807 + { 808 808 + if (verbose) puts("STUB: BOMFSObjectChecksum called"); 809 809 + return NULL; 810 810 + } 811 811 + 812 812 + void* BOMFSObjectContainsArchitecture(void) 813 813 + { 814 814 + if (verbose) puts("STUB: BOMFSObjectContainsArchitecture called"); 815 815 + return NULL; 816 816 + } 817 817 + 818 818 + void* BOMFSObjectCopy(void) 819 819 + { 820 820 + if (verbose) puts("STUB: BOMFSObjectCopy called"); 821 821 + return NULL; 822 822 + } 823 823 + 824 824 + void* BOMFSObjectDeviceID(void) 825 825 + { 826 826 + if (verbose) puts("STUB: BOMFSObjectDeviceID called"); 827 827 + return NULL; 828 828 + } 829 829 + 830 830 + void* BOMFSObjectENewFromPath(void) 831 831 + { 832 832 + if (verbose) puts("STUB: BOMFSObjectENewFromPath called"); 833 833 + return NULL; 834 834 + } 835 835 + 836 836 + void* BOMFSObjectENewFromPathWithSys(void) 837 837 + { 838 838 + if (verbose) puts("STUB: BOMFSObjectENewFromPathWithSys called"); 839 839 + return NULL; 840 840 + } 841 841 + 842 842 + void* BOMFSObjectFree(void) 843 843 + { 844 844 + if (verbose) puts("STUB: BOMFSObjectFree called"); 845 845 + return NULL; 846 846 + } 847 847 + 848 848 + void* BOMFSObjectGetArch(void) 849 849 + { 850 850 + if (verbose) puts("STUB: BOMFSObjectGetArch called"); 851 851 + return NULL; 852 852 + } 853 853 + 854 854 + void* BOMFSObjectGetArchSize(void) 855 855 + { 856 856 + if (verbose) puts("STUB: BOMFSObjectGetArchSize called"); 857 857 + return NULL; 858 858 + } 859 859 + 860 860 + void* BOMFSObjectGetArchSubtype(void) 861 861 + { 862 862 + if (verbose) puts("STUB: BOMFSObjectGetArchSubtype called"); 863 863 + return NULL; 864 864 + } 865 865 + 866 866 + void* BOMFSObjectGetHardlinkCount(void) 867 867 + { 868 868 + if (verbose) puts("STUB: BOMFSObjectGetHardlinkCount called"); 869 869 + return NULL; 870 870 + } 871 871 + 872 872 + void* BOMFSObjectGetHardlinkPath(void) 873 873 + { 874 874 + if (verbose) puts("STUB: BOMFSObjectGetHardlinkPath called"); 875 875 + return NULL; 876 876 + } 877 877 + 878 878 + void* BOMFSObjectGroupID(void) 879 879 + { 880 880 + if (verbose) puts("STUB: BOMFSObjectGroupID called"); 881 881 + return NULL; 882 882 + } 883 883 + 884 884 + void* BOMFSObjectIsBinaryObject(void) 885 885 + { 886 886 + if (verbose) puts("STUB: BOMFSObjectIsBinaryObject called"); 887 887 + return NULL; 888 888 + } 889 889 + 890 890 + void* BOMFSObjectIsHardlink(void) 891 891 + { 892 892 + if (verbose) puts("STUB: BOMFSObjectIsHardlink called"); 893 893 + return NULL; 894 894 + } 895 895 + 896 896 + void* BOMFSObjectModTime(void) 897 897 + { 898 898 + if (verbose) puts("STUB: BOMFSObjectModTime called"); 899 899 + return NULL; 900 900 + } 901 901 + 902 902 + void* BOMFSObjectMode(void) 903 903 + { 904 904 + if (verbose) puts("STUB: BOMFSObjectMode called"); 905 905 + return NULL; 906 906 + } 907 907 + 908 908 + void* BOMFSObjectNew(void) 909 909 + { 910 910 + if (verbose) puts("STUB: BOMFSObjectNew called"); 911 911 + return NULL; 912 912 + } 913 913 + 914 914 + void* BOMFSObjectNewFromPath(void) 915 915 + { 916 916 + if (verbose) puts("STUB: BOMFSObjectNewFromPath called"); 917 917 + return NULL; 918 918 + } 919 919 + 920 920 + void* BOMFSObjectNewFromPathDeferred(void) 921 921 + { 922 922 + if (verbose) puts("STUB: BOMFSObjectNewFromPathDeferred called"); 923 923 + return NULL; 924 924 + } 925 925 + 926 926 + void* BOMFSObjectNewFromPathDeferredWithSys(void) 927 927 + { 928 928 + if (verbose) puts("STUB: BOMFSObjectNewFromPathDeferredWithSys called"); 929 929 + return NULL; 930 930 + } 931 931 + 932 932 + void* BOMFSObjectNewFromPathString(void) 933 933 + { 934 934 + if (verbose) puts("STUB: BOMFSObjectNewFromPathString called"); 935 935 + return NULL; 936 936 + } 937 937 + 938 938 + void* BOMFSObjectNewFromPathStringWithSys(void) 939 939 + { 940 940 + if (verbose) puts("STUB: BOMFSObjectNewFromPathStringWithSys called"); 941 941 + return NULL; 942 942 + } 943 943 + 944 944 + void* BOMFSObjectNewFromPathWithSys(void) 945 945 + { 946 946 + if (verbose) puts("STUB: BOMFSObjectNewFromPathWithSys called"); 947 947 + return NULL; 948 948 + } 949 949 + 950 950 + void* BOMFSObjectNewWithSys(void) 951 951 + { 952 952 + if (verbose) puts("STUB: BOMFSObjectNewWithSys called"); 953 953 + return NULL; 954 954 + } 955 955 + 956 956 + void* BOMFSObjectOpaqueData(void) 957 957 + { 958 958 + if (verbose) puts("STUB: BOMFSObjectOpaqueData called"); 959 959 + return NULL; 960 960 + } 961 961 + 962 962 + void* BOMFSObjectOpaqueDataSize(void) 963 963 + { 964 964 + if (verbose) puts("STUB: BOMFSObjectOpaqueDataSize called"); 965 965 + return NULL; 966 966 + } 967 967 + 968 968 + void* BOMFSObjectParentPathID(void) 969 969 + { 970 970 + if (verbose) puts("STUB: BOMFSObjectParentPathID called"); 971 971 + return NULL; 972 972 + } 973 973 + 974 974 + void* BOMFSObjectParseSummary(void) 975 975 + { 976 976 + if (verbose) puts("STUB: BOMFSObjectParseSummary called"); 977 977 + return NULL; 978 978 + } 979 979 + 980 980 + void* BOMFSObjectParseSummaryWithSys(void) 981 981 + { 982 982 + if (verbose) puts("STUB: BOMFSObjectParseSummaryWithSys called"); 983 983 + return NULL; 984 984 + } 985 985 + 986 986 + void* BOMFSObjectPathID(void) 987 987 + { 988 988 + if (verbose) puts("STUB: BOMFSObjectPathID called"); 989 989 + return NULL; 990 990 + } 991 991 + 992 992 + void* BOMFSObjectPathName(void) 993 993 + { 994 994 + if (verbose) puts("STUB: BOMFSObjectPathName called"); 995 995 + return NULL; 996 996 + } 997 997 + 998 998 + void* BOMFSObjectPathNameString(void) 999 999 + { 1000 1000 + if (verbose) puts("STUB: BOMFSObjectPathNameString called"); 1001 1001 + return NULL; 1002 1002 + } 1003 1003 + 1004 1004 + void* BOMFSObjectSetBlockID(void) 1005 1005 + { 1006 1006 + if (verbose) puts("STUB: BOMFSObjectSetBlockID called"); 1007 1007 + return NULL; 1008 1008 + } 1009 1009 + 1010 1010 + void* BOMFSObjectSetChecksum(void) 1011 1011 + { 1012 1012 + if (verbose) puts("STUB: BOMFSObjectSetChecksum called"); 1013 1013 + return NULL; 1014 1014 + } 1015 1015 + 1016 1016 + void* BOMFSObjectSetDeviceID(void) 1017 1017 + { 1018 1018 + if (verbose) puts("STUB: BOMFSObjectSetDeviceID called"); 1019 1019 + return NULL; 1020 1020 + } 1021 1021 + 1022 1022 + void* BOMFSObjectSetFlags(void) 1023 1023 + { 1024 1024 + if (verbose) puts("STUB: BOMFSObjectSetFlags called"); 1025 1025 + return NULL; 1026 1026 + } 1027 1027 + 1028 1028 + void* BOMFSObjectSetGroupID(void) 1029 1029 + { 1030 1030 + if (verbose) puts("STUB: BOMFSObjectSetGroupID called"); 1031 1031 + return NULL; 1032 1032 + } 1033 1033 + 1034 1034 + void* BOMFSObjectSetModTime(void) 1035 1035 + { 1036 1036 + if (verbose) puts("STUB: BOMFSObjectSetModTime called"); 1037 1037 + return NULL; 1038 1038 + } 1039 1039 + 1040 1040 + void* BOMFSObjectSetMode(void) 1041 1041 + { 1042 1042 + if (verbose) puts("STUB: BOMFSObjectSetMode called"); 1043 1043 + return NULL; 1044 1044 + } 1045 1045 + 1046 1046 + void* BOMFSObjectSetOpaqueData(void) 1047 1047 + { 1048 1048 + if (verbose) puts("STUB: BOMFSObjectSetOpaqueData called"); 1049 1049 + return NULL; 1050 1050 + } 1051 1051 + 1052 1052 + void* BOMFSObjectSetParentPathID(void) 1053 1053 + { 1054 1054 + if (verbose) puts("STUB: BOMFSObjectSetParentPathID called"); 1055 1055 + return NULL; 1056 1056 + } 1057 1057 + 1058 1058 + void* BOMFSObjectSetPathID(void) 1059 1059 + { 1060 1060 + if (verbose) puts("STUB: BOMFSObjectSetPathID called"); 1061 1061 + return NULL; 1062 1062 + } 1063 1063 + 1064 1064 + void* BOMFSObjectSetPathName(void) 1065 1065 + { 1066 1066 + if (verbose) puts("STUB: BOMFSObjectSetPathName called"); 1067 1067 + return NULL; 1068 1068 + } 1069 1069 + 1070 1070 + void* BOMFSObjectSetShortName(void) 1071 1071 + { 1072 1072 + if (verbose) puts("STUB: BOMFSObjectSetShortName called"); 1073 1073 + return NULL; 1074 1074 + } 1075 1075 + 1076 1076 + void* BOMFSObjectSetSize(void) 1077 1077 + { 1078 1078 + if (verbose) puts("STUB: BOMFSObjectSetSize called"); 1079 1079 + return NULL; 1080 1080 + } 1081 1081 + 1082 1082 + void* BOMFSObjectSetSymlinkTarget(void) 1083 1083 + { 1084 1084 + if (verbose) puts("STUB: BOMFSObjectSetSymlinkTarget called"); 1085 1085 + return NULL; 1086 1086 + } 1087 1087 + 1088 1088 + void* BOMFSObjectSetUserID(void) 1089 1089 + { 1090 1090 + if (verbose) puts("STUB: BOMFSObjectSetUserID called"); 1091 1091 + return NULL; 1092 1092 + } 1093 1093 + 1094 1094 + void* BOMFSObjectSetVisitOrder(void) 1095 1095 + { 1096 1096 + if (verbose) puts("STUB: BOMFSObjectSetVisitOrder called"); 1097 1097 + return NULL; 1098 1098 + } 1099 1099 + 1100 1100 + void* BOMFSObjectShortName(void) 1101 1101 + { 1102 1102 + if (verbose) puts("STUB: BOMFSObjectShortName called"); 1103 1103 + return NULL; 1104 1104 + } 1105 1105 + 1106 1106 + void* BOMFSObjectShortNameString(void) 1107 1107 + { 1108 1108 + if (verbose) puts("STUB: BOMFSObjectShortNameString called"); 1109 1109 + return NULL; 1110 1110 + } 1111 1111 + 1112 1112 + void* BOMFSObjectSize(void) 1113 1113 + { 1114 1114 + if (verbose) puts("STUB: BOMFSObjectSize called"); 1115 1115 + return NULL; 1116 1116 + } 1117 1117 + 1118 1118 + void* BOMFSObjectSummary(void) 1119 1119 + { 1120 1120 + if (verbose) puts("STUB: BOMFSObjectSummary called"); 1121 1121 + return NULL; 1122 1122 + } 1123 1123 + 1124 1124 + void* BOMFSObjectSummaryWithFormat(void) 1125 1125 + { 1126 1126 + if (verbose) puts("STUB: BOMFSObjectSummaryWithFormat called"); 1127 1127 + return NULL; 1128 1128 + } 1129 1129 + 1130 1130 + void* BOMFSObjectSymlinkTarget(void) 1131 1131 + { 1132 1132 + if (verbose) puts("STUB: BOMFSObjectSymlinkTarget called"); 1133 1133 + return NULL; 1134 1134 + } 1135 1135 + 1136 1136 + void* BOMFSObjectSymlinkTargetString(void) 1137 1137 + { 1138 1138 + if (verbose) puts("STUB: BOMFSObjectSymlinkTargetString called"); 1139 1139 + return NULL; 1140 1140 + } 1141 1141 + 1142 1142 + void* BOMFSObjectThinKeepingArchs(void) 1143 1143 + { 1144 1144 + if (verbose) puts("STUB: BOMFSObjectThinKeepingArchs called"); 1145 1145 + return NULL; 1146 1146 + } 1147 1147 + 1148 1148 + void* BOMFSObjectType(void) 1149 1149 + { 1150 1150 + if (verbose) puts("STUB: BOMFSObjectType called"); 1151 1151 + return NULL; 1152 1152 + } 1153 1153 + 1154 1154 + void* BOMFSObjectTypeForMode(void) 1155 1155 + { 1156 1156 + if (verbose) puts("STUB: BOMFSObjectTypeForMode called"); 1157 1157 + return NULL; 1158 1158 + } 1159 1159 + 1160 1160 + void* BOMFSObjectTypeFromRawData(void) 1161 1161 + { 1162 1162 + if (verbose) puts("STUB: BOMFSObjectTypeFromRawData called"); 1163 1163 + return NULL; 1164 1164 + } 1165 1165 + 1166 1166 + void* BOMFSObjectUserID(void) 1167 1167 + { 1168 1168 + if (verbose) puts("STUB: BOMFSObjectUserID called"); 1169 1169 + return NULL; 1170 1170 + } 1171 1171 + 1172 1172 + void* BOMFSObjectVisitOrder(void) 1173 1173 + { 1174 1174 + if (verbose) puts("STUB: BOMFSObjectVisitOrder called"); 1175 1175 + return NULL; 1176 1176 + } 1177 1177 + 1178 1178 + void* BOMFileClose(void) 1179 1179 + { 1180 1180 + if (verbose) puts("STUB: BOMFileClose called"); 1181 1181 + return NULL; 1182 1182 + } 1183 1183 + 1184 1184 + void* BOMFileNewFromFD(void) 1185 1185 + { 1186 1186 + if (verbose) puts("STUB: BOMFileNewFromFD called"); 1187 1187 + return NULL; 1188 1188 + } 1189 1189 + 1190 1190 + void* BOMFileNewFromFDWithSys(void) 1191 1191 + { 1192 1192 + if (verbose) puts("STUB: BOMFileNewFromFDWithSys called"); 1193 1193 + return NULL; 1194 1194 + } 1195 1195 + 1196 1196 + void* BOMFileNewMirror(void) 1197 1197 + { 1198 1198 + if (verbose) puts("STUB: BOMFileNewMirror called"); 1199 1199 + return NULL; 1200 1200 + } 1201 1201 + 1202 1202 + void* BOMFileNewMirrorWithSys(void) 1203 1203 + { 1204 1204 + if (verbose) puts("STUB: BOMFileNewMirrorWithSys called"); 1205 1205 + return NULL; 1206 1206 + } 1207 1207 + 1208 1208 + void* BOMFileOffset(void) 1209 1209 + { 1210 1210 + if (verbose) puts("STUB: BOMFileOffset called"); 1211 1211 + return NULL; 1212 1212 + } 1213 1213 + 1214 1214 + void* BOMFileOpen(void) 1215 1215 + { 1216 1216 + if (verbose) puts("STUB: BOMFileOpen called"); 1217 1217 + return NULL; 1218 1218 + } 1219 1219 + 1220 1220 + void* BOMFileOpenSTDIN(void) 1221 1221 + { 1222 1222 + if (verbose) puts("STUB: BOMFileOpenSTDIN called"); 1223 1223 + return NULL; 1224 1224 + } 1225 1225 + 1226 1226 + void* BOMFileOpenSTDOUT(void) 1227 1227 + { 1228 1228 + if (verbose) puts("STUB: BOMFileOpenSTDOUT called"); 1229 1229 + return NULL; 1230 1230 + } 1231 1231 + 1232 1232 + void* BOMFileOpenWithSys(void) 1233 1233 + { 1234 1234 + if (verbose) puts("STUB: BOMFileOpenWithSys called"); 1235 1235 + return NULL; 1236 1236 + } 1237 1237 + 1238 1238 + void* BOMFileRead(void) 1239 1239 + { 1240 1240 + if (verbose) puts("STUB: BOMFileRead called"); 1241 1241 + return NULL; 1242 1242 + } 1243 1243 + 1244 1244 + void* BOMFileSeek(void) 1245 1245 + { 1246 1246 + if (verbose) puts("STUB: BOMFileSeek called"); 1247 1247 + return NULL; 1248 1248 + } 1249 1249 + 1250 1250 + void* BOMFileUncompressedOffset(void) 1251 1251 + { 1252 1252 + if (verbose) puts("STUB: BOMFileUncompressedOffset called"); 1253 1253 + return NULL; 1254 1254 + } 1255 1255 + 1256 1256 + void* BOMFileWrite(void) 1257 1257 + { 1258 1258 + if (verbose) puts("STUB: BOMFileWrite called"); 1259 1259 + return NULL; 1260 1260 + } 1261 1261 + 1262 1262 + void* BOMFilesystemInfoCreate(void) 1263 1263 + { 1264 1264 + if (verbose) puts("STUB: BOMFilesystemInfoCreate called"); 1265 1265 + return NULL; 1266 1266 + } 1267 1267 + 1268 1268 + void* BOMFilesystemInfoDestroy(void) 1269 1269 + { 1270 1270 + if (verbose) puts("STUB: BOMFilesystemInfoDestroy called"); 1271 1271 + return NULL; 1272 1272 + } 1273 1273 + 1274 1274 + void* BOMFilesystemInfoQuery(void) 1275 1275 + { 1276 1276 + if (verbose) puts("STUB: BOMFilesystemInfoQuery called"); 1277 1277 + return NULL; 1278 1278 + } 1279 1279 + 1280 1280 + void* BOMHardLinkTableFree(void) 1281 1281 + { 1282 1282 + if (verbose) puts("STUB: BOMHardLinkTableFree called"); 1283 1283 + return NULL; 1284 1284 + } 1285 1285 + 1286 1286 + void* BOMHardLinkTableGet(void) 1287 1287 + { 1288 1288 + if (verbose) puts("STUB: BOMHardLinkTableGet called"); 1289 1289 + return NULL; 1290 1290 + } 1291 1291 + 1292 1292 + void* BOMHardLinkTableGetPathAndData(void) 1293 1293 + { 1294 1294 + if (verbose) puts("STUB: BOMHardLinkTableGetPathAndData called"); 1295 1295 + return NULL; 1296 1296 + } 1297 1297 + 1298 1298 + void* BOMHardLinkTableNew(void) 1299 1299 + { 1300 1300 + if (verbose) puts("STUB: BOMHardLinkTableNew called"); 1301 1301 + return NULL; 1302 1302 + } 1303 1303 + 1304 1304 + void* BOMHardLinkTableSet(void) 1305 1305 + { 1306 1306 + if (verbose) puts("STUB: BOMHardLinkTableSet called"); 1307 1307 + return NULL; 1308 1308 + } 1309 1309 + 1310 1310 + void* BOMHardLinkTableSetPathAndData(void) 1311 1311 + { 1312 1312 + if (verbose) puts("STUB: BOMHardLinkTableSetPathAndData called"); 1313 1313 + return NULL; 1314 1314 + } 1315 1315 + 1316 1316 + void* BOMMemoryDump(void) 1317 1317 + { 1318 1318 + if (verbose) puts("STUB: BOMMemoryDump called"); 1319 1319 + return NULL; 1320 1320 + } 1321 1321 + 1322 1322 + void* BOMNameForFSObjectType(void) 1323 1323 + { 1324 1324 + if (verbose) puts("STUB: BOMNameForFSObjectType called"); 1325 1325 + return NULL; 1326 1326 + } 1327 1327 + 1328 1328 + void* BOMPatternCompileString(void) 1329 1329 + { 1330 1330 + if (verbose) puts("STUB: BOMPatternCompileString called"); 1331 1331 + return NULL; 1332 1332 + } 1333 1333 + 1334 1334 + void* BOMPatternFree(void) 1335 1335 + { 1336 1336 + if (verbose) puts("STUB: BOMPatternFree called"); 1337 1337 + return NULL; 1338 1338 + } 1339 1339 + 1340 1340 + void* BOMPatternListExtractFromFile(void) 1341 1341 + { 1342 1342 + if (verbose) puts("STUB: BOMPatternListExtractFromFile called"); 1343 1343 + return NULL; 1344 1344 + } 1345 1345 + 1346 1346 + void* BOMPatternListExtractFromStrings(void) 1347 1347 + { 1348 1348 + if (verbose) puts("STUB: BOMPatternListExtractFromStrings called"); 1349 1349 + return NULL; 1350 1350 + } 1351 1351 + 1352 1352 + void* BOMPatternListFree(void) 1353 1353 + { 1354 1354 + if (verbose) puts("STUB: BOMPatternListFree called"); 1355 1355 + return NULL; 1356 1356 + } 1357 1357 + 1358 1358 + void* BOMPatternListFromStringList(void) 1359 1359 + { 1360 1360 + if (verbose) puts("STUB: BOMPatternListFromStringList called"); 1361 1361 + return NULL; 1362 1362 + } 1363 1363 + 1364 1364 + void* BOMPatternListMatch(void) 1365 1365 + { 1366 1366 + if (verbose) puts("STUB: BOMPatternListMatch called"); 1367 1367 + return NULL; 1368 1368 + } 1369 1369 + 1370 1370 + void* BOMPatternListNew(void) 1371 1371 + { 1372 1372 + if (verbose) puts("STUB: BOMPatternListNew called"); 1373 1373 + return NULL; 1374 1374 + } 1375 1375 + 1376 1376 + void* BOMPatternMatch(void) 1377 1377 + { 1378 1378 + if (verbose) puts("STUB: BOMPatternMatch called"); 1379 1379 + return NULL; 1380 1380 + } 1381 1381 + 1382 1382 + void* BOMStackCount(void) 1383 1383 + { 1384 1384 + if (verbose) puts("STUB: BOMStackCount called"); 1385 1385 + return NULL; 1386 1386 + } 1387 1387 + 1388 1388 + void* BOMStackFree(void) 1389 1389 + { 1390 1390 + if (verbose) puts("STUB: BOMStackFree called"); 1391 1391 + return NULL; 1392 1392 + } 1393 1393 + 1394 1394 + void* BOMStackIsEmpty(void) 1395 1395 + { 1396 1396 + if (verbose) puts("STUB: BOMStackIsEmpty called"); 1397 1397 + return NULL; 1398 1398 + } 1399 1399 + 1400 1400 + void* BOMStackNew(void) 1401 1401 + { 1402 1402 + if (verbose) puts("STUB: BOMStackNew called"); 1403 1403 + return NULL; 1404 1404 + } 1405 1405 + 1406 1406 + void* BOMStackPeek(void) 1407 1407 + { 1408 1408 + if (verbose) puts("STUB: BOMStackPeek called"); 1409 1409 + return NULL; 1410 1410 + } 1411 1411 + 1412 1412 + void* BOMStackPoke(void) 1413 1413 + { 1414 1414 + if (verbose) puts("STUB: BOMStackPoke called"); 1415 1415 + return NULL; 1416 1416 + } 1417 1417 + 1418 1418 + void* BOMStackPop(void) 1419 1419 + { 1420 1420 + if (verbose) puts("STUB: BOMStackPop called"); 1421 1421 + return NULL; 1422 1422 + } 1423 1423 + 1424 1424 + void* BOMStackPush(void) 1425 1425 + { 1426 1426 + if (verbose) puts("STUB: BOMStackPush called"); 1427 1427 + return NULL; 1428 1428 + } 1429 1429 + 1430 1430 + void* BOMStorageCommit(void) 1431 1431 + { 1432 1432 + if (verbose) puts("STUB: BOMStorageCommit called"); 1433 1433 + return NULL; 1434 1434 + } 1435 1435 + 1436 1436 + void* BOMStorageCompact(void) 1437 1437 + { 1438 1438 + if (verbose) puts("STUB: BOMStorageCompact called"); 1439 1439 + return NULL; 1440 1440 + } 1441 1441 + 1442 1442 + void* BOMStorageCopyFromBlock(void) 1443 1443 + { 1444 1444 + if (verbose) puts("STUB: BOMStorageCopyFromBlock called"); 1445 1445 + return NULL; 1446 1446 + } 1447 1447 + 1448 1448 + void* BOMStorageCopyFromBlockRange(void) 1449 1449 + { 1450 1450 + if (verbose) puts("STUB: BOMStorageCopyFromBlockRange called"); 1451 1451 + return NULL; 1452 1452 + } 1453 1453 + 1454 1454 + void* BOMStorageCopyToBlock(void) 1455 1455 + { 1456 1456 + if (verbose) puts("STUB: BOMStorageCopyToBlock called"); 1457 1457 + return NULL; 1458 1458 + } 1459 1459 + 1460 1460 + void* BOMStorageCopyToBlockRange(void) 1461 1461 + { 1462 1462 + if (verbose) puts("STUB: BOMStorageCopyToBlockRange called"); 1463 1463 + return NULL; 1464 1464 + } 1465 1465 + 1466 1466 + void* BOMStorageCount(void) 1467 1467 + { 1468 1468 + if (verbose) puts("STUB: BOMStorageCount called"); 1469 1469 + return NULL; 1470 1470 + } 1471 1471 + 1472 1472 + void* BOMStorageDump(void) 1473 1473 + { 1474 1474 + if (verbose) puts("STUB: BOMStorageDump called"); 1475 1475 + return NULL; 1476 1476 + } 1477 1477 + 1478 1478 + void* BOMStorageDumpFreeList(void) 1479 1479 + { 1480 1480 + if (verbose) puts("STUB: BOMStorageDumpFreeList called"); 1481 1481 + return NULL; 1482 1482 + } 1483 1483 + 1484 1484 + void* BOMStorageFileName(void) 1485 1485 + { 1486 1486 + if (verbose) puts("STUB: BOMStorageFileName called"); 1487 1487 + return NULL; 1488 1488 + } 1489 1489 + 1490 1490 + void* BOMStorageFindActualFreeSpace(void) 1491 1491 + { 1492 1492 + if (verbose) puts("STUB: BOMStorageFindActualFreeSpace called"); 1493 1493 + return NULL; 1494 1494 + } 1495 1495 + 1496 1496 + void* BOMStorageFree(void) 1497 1497 + { 1498 1498 + if (verbose) puts("STUB: BOMStorageFree called"); 1499 1499 + return NULL; 1500 1500 + } 1501 1501 + 1502 1502 + void* BOMStorageFreeBlock(void) 1503 1503 + { 1504 1504 + if (verbose) puts("STUB: BOMStorageFreeBlock called"); 1505 1505 + return NULL; 1506 1506 + } 1507 1507 + 1508 1508 + void* BOMStorageFreeNamedBlock(void) 1509 1509 + { 1510 1510 + if (verbose) puts("STUB: BOMStorageFreeNamedBlock called"); 1511 1511 + return NULL; 1512 1512 + } 1513 1513 + 1514 1514 + void* BOMStorageGetNamedBlock(void) 1515 1515 + { 1516 1516 + if (verbose) puts("STUB: BOMStorageGetNamedBlock called"); 1517 1517 + return NULL; 1518 1518 + } 1519 1519 + 1520 1520 + void* BOMStorageGetSys(void) 1521 1521 + { 1522 1522 + if (verbose) puts("STUB: BOMStorageGetSys called"); 1523 1523 + return NULL; 1524 1524 + } 1525 1525 + 1526 1526 + void* BOMStorageIsOpenForWriting(void) 1527 1527 + { 1528 1528 + if (verbose) puts("STUB: BOMStorageIsOpenForWriting called"); 1529 1529 + return NULL; 1530 1530 + } 1531 1531 + 1532 1532 + void* BOMStorageIsStorageFile(void) 1533 1533 + { 1534 1534 + if (verbose) puts("STUB: BOMStorageIsStorageFile called"); 1535 1535 + return NULL; 1536 1536 + } 1537 1537 + 1538 1538 + void* BOMStorageIsStorageFileWithSys(void) 1539 1539 + { 1540 1540 + if (verbose) puts("STUB: BOMStorageIsStorageFileWithSys called"); 1541 1541 + return NULL; 1542 1542 + } 1543 1543 + 1544 1544 + void* BOMStorageNew(void) 1545 1545 + { 1546 1546 + if (verbose) puts("STUB: BOMStorageNew called"); 1547 1547 + return NULL; 1548 1548 + } 1549 1549 + 1550 1550 + void* BOMStorageNewBlock(void) 1551 1551 + { 1552 1552 + if (verbose) puts("STUB: BOMStorageNewBlock called"); 1553 1553 + return NULL; 1554 1554 + } 1555 1555 + 1556 1556 + void* BOMStorageNewInRAM(void) 1557 1557 + { 1558 1558 + if (verbose) puts("STUB: BOMStorageNewInRAM called"); 1559 1559 + return NULL; 1560 1560 + } 1561 1561 + 1562 1562 + void* BOMStorageNewNamedBlock(void) 1563 1563 + { 1564 1564 + if (verbose) puts("STUB: BOMStorageNewNamedBlock called"); 1565 1565 + return NULL; 1566 1566 + } 1567 1567 + 1568 1568 + void* BOMStorageNewWithOptions(void) 1569 1569 + { 1570 1570 + if (verbose) puts("STUB: BOMStorageNewWithOptions called"); 1571 1571 + return NULL; 1572 1572 + } 1573 1573 + 1574 1574 + void* BOMStorageNewWithOptionsAndSys(void) 1575 1575 + { 1576 1576 + if (verbose) puts("STUB: BOMStorageNewWithOptionsAndSys called"); 1577 1577 + return NULL; 1578 1578 + } 1579 1579 + 1580 1580 + void* BOMStorageNewWithSys(void) 1581 1581 + { 1582 1582 + if (verbose) puts("STUB: BOMStorageNewWithSys called"); 1583 1583 + return NULL; 1584 1584 + } 1585 1585 + 1586 1586 + void* BOMStorageOpen(void) 1587 1587 + { 1588 1588 + if (verbose) puts("STUB: BOMStorageOpen called"); 1589 1589 + return NULL; 1590 1590 + } 1591 1591 + 1592 1592 + void* BOMStorageOpenInRAM(void) 1593 1593 + { 1594 1594 + if (verbose) puts("STUB: BOMStorageOpenInRAM called"); 1595 1595 + return NULL; 1596 1596 + } 1597 1597 + 1598 1598 + void* BOMStorageOpenWithSys(void) 1599 1599 + { 1600 1600 + if (verbose) puts("STUB: BOMStorageOpenWithSys called"); 1601 1601 + return NULL; 1602 1602 + } 1603 1603 + 1604 1604 + void* BOMStorageSetBlockData(void) 1605 1605 + { 1606 1606 + if (verbose) puts("STUB: BOMStorageSetBlockData called"); 1607 1607 + return NULL; 1608 1608 + } 1609 1609 + 1610 1610 + void* BOMStorageSizeOfBlock(void) 1611 1611 + { 1612 1612 + if (verbose) puts("STUB: BOMStorageSizeOfBlock called"); 1613 1613 + return NULL; 1614 1614 + } 1615 1615 + 1616 1616 + void* BOMStreamFlush(void) 1617 1617 + { 1618 1618 + if (verbose) puts("STUB: BOMStreamFlush called"); 1619 1619 + return NULL; 1620 1620 + } 1621 1621 + 1622 1622 + void* BOMStreamFree(void) 1623 1623 + { 1624 1624 + if (verbose) puts("STUB: BOMStreamFree called"); 1625 1625 + return NULL; 1626 1626 + } 1627 1627 + 1628 1628 + void* BOMStreamGetByteOrder(void) 1629 1629 + { 1630 1630 + if (verbose) puts("STUB: BOMStreamGetByteOrder called"); 1631 1631 + return NULL; 1632 1632 + } 1633 1633 + 1634 1634 + void* BOMStreamGetSys(void) 1635 1635 + { 1636 1636 + if (verbose) puts("STUB: BOMStreamGetSys called"); 1637 1637 + return NULL; 1638 1638 + } 1639 1639 + 1640 1640 + void* BOMStreamReadAddress(void) 1641 1641 + { 1642 1642 + if (verbose) puts("STUB: BOMStreamReadAddress called"); 1643 1643 + return NULL; 1644 1644 + } 1645 1645 + 1646 1646 + void* BOMStreamReadBuffer(void) 1647 1647 + { 1648 1648 + if (verbose) puts("STUB: BOMStreamReadBuffer called"); 1649 1649 + return NULL; 1650 1650 + } 1651 1651 + 1652 1652 + void* BOMStreamReadUInt16(void) 1653 1653 + { 1654 1654 + if (verbose) puts("STUB: BOMStreamReadUInt16 called"); 1655 1655 + return NULL; 1656 1656 + } 1657 1657 + 1658 1658 + void* BOMStreamReadUInt32(void) 1659 1659 + { 1660 1660 + if (verbose) puts("STUB: BOMStreamReadUInt32 called"); 1661 1661 + return NULL; 1662 1662 + } 1663 1663 + 1664 1664 + void* BOMStreamReadUInt8(void) 1665 1665 + { 1666 1666 + if (verbose) puts("STUB: BOMStreamReadUInt8 called"); 1667 1667 + return NULL; 1668 1668 + } 1669 1669 + 1670 1670 + void* BOMStreamSetByteOrder(void) 1671 1671 + { 1672 1672 + if (verbose) puts("STUB: BOMStreamSetByteOrder called"); 1673 1673 + return NULL; 1674 1674 + } 1675 1675 + 1676 1676 + void* BOMStreamWithAddress(void) 1677 1677 + { 1678 1678 + if (verbose) puts("STUB: BOMStreamWithAddress called"); 1679 1679 + return NULL; 1680 1680 + } 1681 1681 + 1682 1682 + void* BOMStreamWithBlockID(void) 1683 1683 + { 1684 1684 + if (verbose) puts("STUB: BOMStreamWithBlockID called"); 1685 1685 + return NULL; 1686 1686 + } 1687 1687 + 1688 1688 + void* BOMStreamWithFile(void) 1689 1689 + { 1690 1690 + if (verbose) puts("STUB: BOMStreamWithFile called"); 1691 1691 + return NULL; 1692 1692 + } 1693 1693 + 1694 1694 + void* BOMStreamWithFileAndSys(void) 1695 1695 + { 1696 1696 + if (verbose) puts("STUB: BOMStreamWithFileAndSys called"); 1697 1697 + return NULL; 1698 1698 + } 1699 1699 + 1700 1700 + void* BOMStreamWriteBuffer(void) 1701 1701 + { 1702 1702 + if (verbose) puts("STUB: BOMStreamWriteBuffer called"); 1703 1703 + return NULL; 1704 1704 + } 1705 1705 + 1706 1706 + void* BOMStreamWriteUInt16(void) 1707 1707 + { 1708 1708 + if (verbose) puts("STUB: BOMStreamWriteUInt16 called"); 1709 1709 + return NULL; 1710 1710 + } 1711 1711 + 1712 1712 + void* BOMStreamWriteUInt32(void) 1713 1713 + { 1714 1714 + if (verbose) puts("STUB: BOMStreamWriteUInt32 called"); 1715 1715 + return NULL; 1716 1716 + } 1717 1717 + 1718 1718 + void* BOMStreamWriteUInt8(void) 1719 1719 + { 1720 1720 + if (verbose) puts("STUB: BOMStreamWriteUInt8 called"); 1721 1721 + return NULL; 1722 1722 + } 1723 1723 + 1724 1724 + void* BOMTreeCommit(void) 1725 1725 + { 1726 1726 + if (verbose) puts("STUB: BOMTreeCommit called"); 1727 1727 + return NULL; 1728 1728 + } 1729 1729 + 1730 1730 + void* BOMTreeCopyToTree(void) 1731 1731 + { 1732 1732 + if (verbose) puts("STUB: BOMTreeCopyToTree called"); 1733 1733 + return NULL; 1734 1734 + } 1735 1735 + 1736 1736 + void* BOMTreeCount(void) 1737 1737 + { 1738 1738 + if (verbose) puts("STUB: BOMTreeCount called"); 1739 1739 + return NULL; 1740 1740 + } 1741 1741 + 1742 1742 + void* BOMTreeFree(void) 1743 1743 + { 1744 1744 + if (verbose) puts("STUB: BOMTreeFree called"); 1745 1745 + return NULL; 1746 1746 + } 1747 1747 + 1748 1748 + void* BOMTreeGetValue(void) 1749 1749 + { 1750 1750 + if (verbose) puts("STUB: BOMTreeGetValue called"); 1751 1751 + return NULL; 1752 1752 + } 1753 1753 + 1754 1754 + void* BOMTreeGetValueSize(void) 1755 1755 + { 1756 1756 + if (verbose) puts("STUB: BOMTreeGetValueSize called"); 1757 1757 + return NULL; 1758 1758 + } 1759 1759 + 1760 1760 + void* BOMTreeIteratorFree(void) 1761 1761 + { 1762 1762 + if (verbose) puts("STUB: BOMTreeIteratorFree called"); 1763 1763 + return NULL; 1764 1764 + } 1765 1765 + 1766 1766 + void* BOMTreeIteratorIsAtEnd(void) 1767 1767 + { 1768 1768 + if (verbose) puts("STUB: BOMTreeIteratorIsAtEnd called"); 1769 1769 + return NULL; 1770 1770 + } 1771 1771 + 1772 1772 + void* BOMTreeIteratorKey(void) 1773 1773 + { 1774 1774 + if (verbose) puts("STUB: BOMTreeIteratorKey called"); 1775 1775 + return NULL; 1776 1776 + } 1777 1777 + 1778 1778 + void* BOMTreeIteratorKeySize(void) 1779 1779 + { 1780 1780 + if (verbose) puts("STUB: BOMTreeIteratorKeySize called"); 1781 1781 + return NULL; 1782 1782 + } 1783 1783 + 1784 1784 + void* BOMTreeIteratorNew(void) 1785 1785 + { 1786 1786 + if (verbose) puts("STUB: BOMTreeIteratorNew called"); 1787 1787 + return NULL; 1788 1788 + } 1789 1789 + 1790 1790 + void* BOMTreeIteratorNext(void) 1791 1791 + { 1792 1792 + if (verbose) puts("STUB: BOMTreeIteratorNext called"); 1793 1793 + return NULL; 1794 1794 + } 1795 1795 + 1796 1796 + void* BOMTreeIteratorSet(void) 1797 1797 + { 1798 1798 + if (verbose) puts("STUB: BOMTreeIteratorSet called"); 1799 1799 + return NULL; 1800 1800 + } 1801 1801 + 1802 1802 + void* BOMTreeIteratorValue(void) 1803 1803 + { 1804 1804 + if (verbose) puts("STUB: BOMTreeIteratorValue called"); 1805 1805 + return NULL; 1806 1806 + } 1807 1807 + 1808 1808 + void* BOMTreeIteratorValueSize(void) 1809 1809 + { 1810 1810 + if (verbose) puts("STUB: BOMTreeIteratorValueSize called"); 1811 1811 + return NULL; 1812 1812 + } 1813 1813 + 1814 1814 + void* BOMTreeNew(void) 1815 1815 + { 1816 1816 + if (verbose) puts("STUB: BOMTreeNew called"); 1817 1817 + return NULL; 1818 1818 + } 1819 1819 + 1820 1820 + void* BOMTreeNewWithName(void) 1821 1821 + { 1822 1822 + if (verbose) puts("STUB: BOMTreeNewWithName called"); 1823 1823 + return NULL; 1824 1824 + } 1825 1825 + 1826 1826 + void* BOMTreeNewWithOptions(void) 1827 1827 + { 1828 1828 + if (verbose) puts("STUB: BOMTreeNewWithOptions called"); 1829 1829 + return NULL; 1830 1830 + } 1831 1831 + 1832 1832 + void* BOMTreeOpen(void) 1833 1833 + { 1834 1834 + if (verbose) puts("STUB: BOMTreeOpen called"); 1835 1835 + return NULL; 1836 1836 + } 1837 1837 + 1838 1838 + void* BOMTreeOpenWithName(void) 1839 1839 + { 1840 1840 + if (verbose) puts("STUB: BOMTreeOpenWithName called"); 1841 1841 + return NULL; 1842 1842 + } 1843 1843 + 1844 1844 + void* BOMTreeRemoveAndFree(void) 1845 1845 + { 1846 1846 + if (verbose) puts("STUB: BOMTreeRemoveAndFree called"); 1847 1847 + return NULL; 1848 1848 + } 1849 1849 + 1850 1850 + void* BOMTreeRemoveValue(void) 1851 1851 + { 1852 1852 + if (verbose) puts("STUB: BOMTreeRemoveValue called"); 1853 1853 + return NULL; 1854 1854 + } 1855 1855 + 1856 1856 + void* BOMTreeSetCompareFunc(void) 1857 1857 + { 1858 1858 + if (verbose) puts("STUB: BOMTreeSetCompareFunc called"); 1859 1859 + return NULL; 1860 1860 + } 1861 1861 + 1862 1862 + void* BOMTreeSetValue(void) 1863 1863 + { 1864 1864 + if (verbose) puts("STUB: BOMTreeSetValue called"); 1865 1865 + return NULL; 1866 1866 + } 1867 1867 + 1868 1868 + void* BOMTreeStorage(void) 1869 1869 + { 1870 1870 + if (verbose) puts("STUB: BOMTreeStorage called"); 1871 1871 + return NULL; 1872 1872 + } 1873 1873 + 1874 1874 + void* BOM_calloc(void) 1875 1875 + { 1876 1876 + if (verbose) puts("STUB: BOM_calloc called"); 1877 1877 + return NULL; 1878 1878 + } 1879 1879 + 1880 1880 + void* BOM_malloc(void) 1881 1881 + { 1882 1882 + if (verbose) puts("STUB: BOM_malloc called"); 1883 1883 + return NULL; 1884 1884 + } 1885 1885 + 1886 1886 + void* BOM_malloczero(void) 1887 1887 + { 1888 1888 + if (verbose) puts("STUB: BOM_malloczero called"); 1889 1889 + return NULL; 1890 1890 + } 1891 1891 + 1892 1892 + void* BOM_realloc(void) 1893 1893 + { 1894 1894 + if (verbose) puts("STUB: BOM_realloc called"); 1895 1895 + return NULL; 1896 1896 + } 1897 1897 + 1898 1898 + void* BOM_realloczero(void) 1899 1899 + { 1900 1900 + if (verbose) puts("STUB: BOM_realloczero called"); 1901 1901 + return NULL; 1902 1902 + } 1903 1903 + 1904 1904 + void* BOM_strrncmp(void) 1905 1905 + { 1906 1906 + if (verbose) puts("STUB: BOM_strrncmp called"); 1907 1907 + return NULL; 1908 1908 + } 1909 1909 + 1910 1910 + void* BomSys_access(void) 1911 1911 + { 1912 1912 + if (verbose) puts("STUB: BomSys_access called"); 1913 1913 + return NULL; 1914 1914 + } 1915 1915 + 1916 1916 + void* BomSys_chdir(void) 1917 1917 + { 1918 1918 + if (verbose) puts("STUB: BomSys_chdir called"); 1919 1919 + return NULL; 1920 1920 + } 1921 1921 + 1922 1922 + void* BomSys_chflags(void) 1923 1923 + { 1924 1924 + if (verbose) puts("STUB: BomSys_chflags called"); 1925 1925 + return NULL; 1926 1926 + } 1927 1927 + 1928 1928 + void* BomSys_chmod(void) 1929 1929 + { 1930 1930 + if (verbose) puts("STUB: BomSys_chmod called"); 1931 1931 + return NULL; 1932 1932 + } 1933 1933 + 1934 1934 + void* BomSys_close(void) 1935 1935 + { 1936 1936 + if (verbose) puts("STUB: BomSys_close called"); 1937 1937 + return NULL; 1938 1938 + } 1939 1939 + 1940 1940 + void* BomSys_closedir(void) 1941 1941 + { 1942 1942 + if (verbose) puts("STUB: BomSys_closedir called"); 1943 1943 + return NULL; 1944 1944 + } 1945 1945 + 1946 1946 + void* BomSys_default(void) 1947 1947 + { 1948 1948 + if (verbose) puts("STUB: BomSys_default called"); 1949 1949 + return NULL; 1950 1950 + } 1951 1951 + 1952 1952 + void* BomSys_fcntl(void) 1953 1953 + { 1954 1954 + if (verbose) puts("STUB: BomSys_fcntl called"); 1955 1955 + return NULL; 1956 1956 + } 1957 1957 + 1958 1958 + void* BomSys_free(void) 1959 1959 + { 1960 1960 + if (verbose) puts("STUB: BomSys_free called"); 1961 1961 + return NULL; 1962 1962 + } 1963 1963 + 1964 1964 + void* BomSys_fstat(void) 1965 1965 + { 1966 1966 + if (verbose) puts("STUB: BomSys_fstat called"); 1967 1967 + return NULL; 1968 1968 + } 1969 1969 + 1970 1970 + void* BomSys_fstatfs(void) 1971 1971 + { 1972 1972 + if (verbose) puts("STUB: BomSys_fstatfs called"); 1973 1973 + return NULL; 1974 1974 + } 1975 1975 + 1976 1976 + void* BomSys_fsync(void) 1977 1977 + { 1978 1978 + if (verbose) puts("STUB: BomSys_fsync called"); 1979 1979 + return NULL; 1980 1980 + } 1981 1981 + 1982 1982 + void* BomSys_getattrlist(void) 1983 1983 + { 1984 1984 + if (verbose) puts("STUB: BomSys_getattrlist called"); 1985 1985 + return NULL; 1986 1986 + } 1987 1987 + 1988 1988 + void* BomSys_getcwd(void) 1989 1989 + { 1990 1990 + if (verbose) puts("STUB: BomSys_getcwd called"); 1991 1991 + return NULL; 1992 1992 + } 1993 1993 + 1994 1994 + void* BomSys_getxattr(void) 1995 1995 + { 1996 1996 + if (verbose) puts("STUB: BomSys_getxattr called"); 1997 1997 + return NULL; 1998 1998 + } 1999 1999 + 2000 2000 + void* BomSys_init(void) 2001 2001 + { 2002 2002 + if (verbose) puts("STUB: BomSys_init called"); 2003 2003 + return NULL; 2004 2004 + } 2005 2005 + 2006 2006 + void* BomSys_lchown(void) 2007 2007 + { 2008 2008 + if (verbose) puts("STUB: BomSys_lchown called"); 2009 2009 + return NULL; 2010 2010 + } 2011 2011 + 2012 2012 + void* BomSys_link(void) 2013 2013 + { 2014 2014 + if (verbose) puts("STUB: BomSys_link called"); 2015 2015 + return NULL; 2016 2016 + } 2017 2017 + 2018 2018 + void* BomSys_listxattr(void) 2019 2019 + { 2020 2020 + if (verbose) puts("STUB: BomSys_listxattr called"); 2021 2021 + return NULL; 2022 2022 + } 2023 2023 + 2024 2024 + void* BomSys_log_attach(void) 2025 2025 + { 2026 2026 + if (verbose) puts("STUB: BomSys_log_attach called"); 2027 2027 + return NULL; 2028 2028 + } 2029 2029 + 2030 2030 + void* BomSys_log_attached(void) 2031 2031 + { 2032 2032 + if (verbose) puts("STUB: BomSys_log_attached called"); 2033 2033 + return NULL; 2034 2034 + } 2035 2035 + 2036 2036 + void* BomSys_log_config(void) 2037 2037 + { 2038 2038 + if (verbose) puts("STUB: BomSys_log_config called"); 2039 2039 + return NULL; 2040 2040 + } 2041 2041 + 2042 2042 + void* BomSys_log_detach(void) 2043 2043 + { 2044 2044 + if (verbose) puts("STUB: BomSys_log_detach called"); 2045 2045 + return NULL; 2046 2046 + } 2047 2047 + 2048 2048 + void* BomSys_log_pause(void) 2049 2049 + { 2050 2050 + if (verbose) puts("STUB: BomSys_log_pause called"); 2051 2051 + return NULL; 2052 2052 + } 2053 2053 + 2054 2054 + void* BomSys_log_resume(void) 2055 2055 + { 2056 2056 + if (verbose) puts("STUB: BomSys_log_resume called"); 2057 2057 + return NULL; 2058 2058 + } 2059 2059 + 2060 2060 + void* BomSys_lseek(void) 2061 2061 + { 2062 2062 + if (verbose) puts("STUB: BomSys_lseek called"); 2063 2063 + return NULL; 2064 2064 + } 2065 2065 + 2066 2066 + void* BomSys_lstat(void) 2067 2067 + { 2068 2068 + if (verbose) puts("STUB: BomSys_lstat called"); 2069 2069 + return NULL; 2070 2070 + } 2071 2071 + 2072 2072 + void* BomSys_mkdir(void) 2073 2073 + { 2074 2074 + if (verbose) puts("STUB: BomSys_mkdir called"); 2075 2075 + return NULL; 2076 2076 + } 2077 2077 + 2078 2078 + void* BomSys_mknod(void) 2079 2079 + { 2080 2080 + if (verbose) puts("STUB: BomSys_mknod called"); 2081 2081 + return NULL; 2082 2082 + } 2083 2083 + 2084 2084 + void* BomSys_mktemp(void) 2085 2085 + { 2086 2086 + if (verbose) puts("STUB: BomSys_mktemp called"); 2087 2087 + return NULL; 2088 2088 + } 2089 2089 + 2090 2090 + void* BomSys_mmap(void) 2091 2091 + { 2092 2092 + if (verbose) puts("STUB: BomSys_mmap called"); 2093 2093 + return NULL; 2094 2094 + } 2095 2095 + 2096 2096 + void* BomSys_munmap(void) 2097 2097 + { 2098 2098 + if (verbose) puts("STUB: BomSys_munmap called"); 2099 2099 + return NULL; 2100 2100 + } 2101 2101 + 2102 2102 + void* BomSys_open(void) 2103 2103 + { 2104 2104 + if (verbose) puts("STUB: BomSys_open called"); 2105 2105 + return NULL; 2106 2106 + } 2107 2107 + 2108 2108 + void* BomSys_openFor(void) 2109 2109 + { 2110 2110 + if (verbose) puts("STUB: BomSys_openFor called"); 2111 2111 + return NULL; 2112 2112 + } 2113 2113 + 2114 2114 + void* BomSys_opendir(void) 2115 2115 + { 2116 2116 + if (verbose) puts("STUB: BomSys_opendir called"); 2117 2117 + return NULL; 2118 2118 + } 2119 2119 + 2120 2120 + void* BomSys_read(void) 2121 2121 + { 2122 2122 + if (verbose) puts("STUB: BomSys_read called"); 2123 2123 + return NULL; 2124 2124 + } 2125 2125 + 2126 2126 + void* BomSys_readdir(void) 2127 2127 + { 2128 2128 + if (verbose) puts("STUB: BomSys_readdir called"); 2129 2129 + return NULL; 2130 2130 + } 2131 2131 + 2132 2132 + void* BomSys_readdir_r(void) 2133 2133 + { 2134 2134 + if (verbose) puts("STUB: BomSys_readdir_r called"); 2135 2135 + return NULL; 2136 2136 + } 2137 2137 + 2138 2138 + void* BomSys_readlink(void) 2139 2139 + { 2140 2140 + if (verbose) puts("STUB: BomSys_readlink called"); 2141 2141 + return NULL; 2142 2142 + } 2143 2143 + 2144 2144 + void* BomSys_realpath(void) 2145 2145 + { 2146 2146 + if (verbose) puts("STUB: BomSys_realpath called"); 2147 2147 + return NULL; 2148 2148 + } 2149 2149 + 2150 2150 + void* BomSys_removexattr(void) 2151 2151 + { 2152 2152 + if (verbose) puts("STUB: BomSys_removexattr called"); 2153 2153 + return NULL; 2154 2154 + } 2155 2155 + 2156 2156 + void* BomSys_rename(void) 2157 2157 + { 2158 2158 + if (verbose) puts("STUB: BomSys_rename called"); 2159 2159 + return NULL; 2160 2160 + } 2161 2161 + 2162 2162 + void* BomSys_rmdir(void) 2163 2163 + { 2164 2164 + if (verbose) puts("STUB: BomSys_rmdir called"); 2165 2165 + return NULL; 2166 2166 + } 2167 2167 + 2168 2168 + void* BomSys_set_access(void) 2169 2169 + { 2170 2170 + if (verbose) puts("STUB: BomSys_set_access called"); 2171 2171 + return NULL; 2172 2172 + } 2173 2173 + 2174 2174 + void* BomSys_set_chdir(void) 2175 2175 + { 2176 2176 + if (verbose) puts("STUB: BomSys_set_chdir called"); 2177 2177 + return NULL; 2178 2178 + } 2179 2179 + 2180 2180 + void* BomSys_set_chflags(void) 2181 2181 + { 2182 2182 + if (verbose) puts("STUB: BomSys_set_chflags called"); 2183 2183 + return NULL; 2184 2184 + } 2185 2185 + 2186 2186 + void* BomSys_set_chmod(void) 2187 2187 + { 2188 2188 + if (verbose) puts("STUB: BomSys_set_chmod called"); 2189 2189 + return NULL; 2190 2190 + } 2191 2191 + 2192 2192 + void* BomSys_set_close(void) 2193 2193 + { 2194 2194 + if (verbose) puts("STUB: BomSys_set_close called"); 2195 2195 + return NULL; 2196 2196 + } 2197 2197 + 2198 2198 + void* BomSys_set_closedir(void) 2199 2199 + { 2200 2200 + if (verbose) puts("STUB: BomSys_set_closedir called"); 2201 2201 + return NULL; 2202 2202 + } 2203 2203 + 2204 2204 + void* BomSys_set_fcntl(void) 2205 2205 + { 2206 2206 + if (verbose) puts("STUB: BomSys_set_fcntl called"); 2207 2207 + return NULL; 2208 2208 + } 2209 2209 + 2210 2210 + void* BomSys_set_fstat(void) 2211 2211 + { 2212 2212 + if (verbose) puts("STUB: BomSys_set_fstat called"); 2213 2213 + return NULL; 2214 2214 + } 2215 2215 + 2216 2216 + void* BomSys_set_fstatfs(void) 2217 2217 + { 2218 2218 + if (verbose) puts("STUB: BomSys_set_fstatfs called"); 2219 2219 + return NULL; 2220 2220 + } 2221 2221 + 2222 2222 + void* BomSys_set_fsync(void) 2223 2223 + { 2224 2224 + if (verbose) puts("STUB: BomSys_set_fsync called"); 2225 2225 + return NULL; 2226 2226 + } 2227 2227 + 2228 2228 + void* BomSys_set_getattrlist(void) 2229 2229 + { 2230 2230 + if (verbose) puts("STUB: BomSys_set_getattrlist called"); 2231 2231 + return NULL; 2232 2232 + } 2233 2233 + 2234 2234 + void* BomSys_set_getcwd(void) 2235 2235 + { 2236 2236 + if (verbose) puts("STUB: BomSys_set_getcwd called"); 2237 2237 + return NULL; 2238 2238 + } 2239 2239 + 2240 2240 + void* BomSys_set_getxattr(void) 2241 2241 + { 2242 2242 + if (verbose) puts("STUB: BomSys_set_getxattr called"); 2243 2243 + return NULL; 2244 2244 + } 2245 2245 + 2246 2246 + void* BomSys_set_lchown(void) 2247 2247 + { 2248 2248 + if (verbose) puts("STUB: BomSys_set_lchown called"); 2249 2249 + return NULL; 2250 2250 + } 2251 2251 + 2252 2252 + void* BomSys_set_link(void) 2253 2253 + { 2254 2254 + if (verbose) puts("STUB: BomSys_set_link called"); 2255 2255 + return NULL; 2256 2256 + } 2257 2257 + 2258 2258 + void* BomSys_set_listxattr(void) 2259 2259 + { 2260 2260 + if (verbose) puts("STUB: BomSys_set_listxattr called"); 2261 2261 + return NULL; 2262 2262 + } 2263 2263 + 2264 2264 + void* BomSys_set_lseek(void) 2265 2265 + { 2266 2266 + if (verbose) puts("STUB: BomSys_set_lseek called"); 2267 2267 + return NULL; 2268 2268 + } 2269 2269 + 2270 2270 + void* BomSys_set_lstat(void) 2271 2271 + { 2272 2272 + if (verbose) puts("STUB: BomSys_set_lstat called"); 2273 2273 + return NULL; 2274 2274 + } 2275 2275 + 2276 2276 + void* BomSys_set_mkdir(void) 2277 2277 + { 2278 2278 + if (verbose) puts("STUB: BomSys_set_mkdir called"); 2279 2279 + return NULL; 2280 2280 + } 2281 2281 + 2282 2282 + void* BomSys_set_mknod(void) 2283 2283 + { 2284 2284 + if (verbose) puts("STUB: BomSys_set_mknod called"); 2285 2285 + return NULL; 2286 2286 + } 2287 2287 + 2288 2288 + void* BomSys_set_mktemp(void) 2289 2289 + { 2290 2290 + if (verbose) puts("STUB: BomSys_set_mktemp called"); 2291 2291 + return NULL; 2292 2292 + } 2293 2293 + 2294 2294 + void* BomSys_set_mmap(void) 2295 2295 + { 2296 2296 + if (verbose) puts("STUB: BomSys_set_mmap called"); 2297 2297 + return NULL; 2298 2298 + } 2299 2299 + 2300 2300 + void* BomSys_set_munmap(void) 2301 2301 + { 2302 2302 + if (verbose) puts("STUB: BomSys_set_munmap called"); 2303 2303 + return NULL; 2304 2304 + } 2305 2305 + 2306 2306 + void* BomSys_set_open(void) 2307 2307 + { 2308 2308 + if (verbose) puts("STUB: BomSys_set_open called"); 2309 2309 + return NULL; 2310 2310 + } 2311 2311 + 2312 2312 + void* BomSys_set_openFor(void) 2313 2313 + { 2314 2314 + if (verbose) puts("STUB: BomSys_set_openFor called"); 2315 2315 + return NULL; 2316 2316 + } 2317 2317 + 2318 2318 + void* BomSys_set_opendir(void) 2319 2319 + { 2320 2320 + if (verbose) puts("STUB: BomSys_set_opendir called"); 2321 2321 + return NULL; 2322 2322 + } 2323 2323 + 2324 2324 + void* BomSys_set_read(void) 2325 2325 + { 2326 2326 + if (verbose) puts("STUB: BomSys_set_read called"); 2327 2327 + return NULL; 2328 2328 + } 2329 2329 + 2330 2330 + void* BomSys_set_readdir(void) 2331 2331 + { 2332 2332 + if (verbose) puts("STUB: BomSys_set_readdir called"); 2333 2333 + return NULL; 2334 2334 + } 2335 2335 + 2336 2336 + void* BomSys_set_readdir_r(void) 2337 2337 + { 2338 2338 + if (verbose) puts("STUB: BomSys_set_readdir_r called"); 2339 2339 + return NULL; 2340 2340 + } 2341 2341 + 2342 2342 + void* BomSys_set_readlink(void) 2343 2343 + { 2344 2344 + if (verbose) puts("STUB: BomSys_set_readlink called"); 2345 2345 + return NULL; 2346 2346 + } 2347 2347 + 2348 2348 + void* BomSys_set_realpath(void) 2349 2349 + { 2350 2350 + if (verbose) puts("STUB: BomSys_set_realpath called"); 2351 2351 + return NULL; 2352 2352 + } 2353 2353 + 2354 2354 + void* BomSys_set_removexattr(void) 2355 2355 + { 2356 2356 + if (verbose) puts("STUB: BomSys_set_removexattr called"); 2357 2357 + return NULL; 2358 2358 + } 2359 2359 + 2360 2360 + void* BomSys_set_rename(void) 2361 2361 + { 2362 2362 + if (verbose) puts("STUB: BomSys_set_rename called"); 2363 2363 + return NULL; 2364 2364 + } 2365 2365 + 2366 2366 + void* BomSys_set_rmdir(void) 2367 2367 + { 2368 2368 + if (verbose) puts("STUB: BomSys_set_rmdir called"); 2369 2369 + return NULL; 2370 2370 + } 2371 2371 + 2372 2372 + void* BomSys_set_setxattr(void) 2373 2373 + { 2374 2374 + if (verbose) puts("STUB: BomSys_set_setxattr called"); 2375 2375 + return NULL; 2376 2376 + } 2377 2377 + 2378 2378 + void* BomSys_set_stat(void) 2379 2379 + { 2380 2380 + if (verbose) puts("STUB: BomSys_set_stat called"); 2381 2381 + return NULL; 2382 2382 + } 2383 2383 + 2384 2384 + void* BomSys_set_statfs(void) 2385 2385 + { 2386 2386 + if (verbose) puts("STUB: BomSys_set_statfs called"); 2387 2387 + return NULL; 2388 2388 + } 2389 2389 + 2390 2390 + void* BomSys_set_symlink(void) 2391 2391 + { 2392 2392 + if (verbose) puts("STUB: BomSys_set_symlink called"); 2393 2393 + return NULL; 2394 2394 + } 2395 2395 + 2396 2396 + void* BomSys_set_unlink(void) 2397 2397 + { 2398 2398 + if (verbose) puts("STUB: BomSys_set_unlink called"); 2399 2399 + return NULL; 2400 2400 + } 2401 2401 + 2402 2402 + void* BomSys_set_utimes(void) 2403 2403 + { 2404 2404 + if (verbose) puts("STUB: BomSys_set_utimes called"); 2405 2405 + return NULL; 2406 2406 + } 2407 2407 + 2408 2408 + void* BomSys_set_write(void) 2409 2409 + { 2410 2410 + if (verbose) puts("STUB: BomSys_set_write called"); 2411 2411 + return NULL; 2412 2412 + } 2413 2413 + 2414 2414 + void* BomSys_setxattr(void) 2415 2415 + { 2416 2416 + if (verbose) puts("STUB: BomSys_setxattr called"); 2417 2417 + return NULL; 2418 2418 + } 2419 2419 + 2420 2420 + void* BomSys_stat(void) 2421 2421 + { 2422 2422 + if (verbose) puts("STUB: BomSys_stat called"); 2423 2423 + return NULL; 2424 2424 + } 2425 2425 + 2426 2426 + void* BomSys_statfs(void) 2427 2427 + { 2428 2428 + if (verbose) puts("STUB: BomSys_statfs called"); 2429 2429 + return NULL; 2430 2430 + } 2431 2431 + 2432 2432 + void* BomSys_symlink(void) 2433 2433 + { 2434 2434 + if (verbose) puts("STUB: BomSys_symlink called"); 2435 2435 + return NULL; 2436 2436 + } 2437 2437 + 2438 2438 + void* BomSys_unlink(void) 2439 2439 + { 2440 2440 + if (verbose) puts("STUB: BomSys_unlink called"); 2441 2441 + return NULL; 2442 2442 + } 2443 2443 + 2444 2444 + void* BomSys_utimes(void) 2445 2445 + { 2446 2446 + if (verbose) puts("STUB: BomSys_utimes called"); 2447 2447 + return NULL; 2448 2448 + } 2449 2449 + 2450 2450 + void* BomSys_write(void) 2451 2451 + { 2452 2452 + if (verbose) puts("STUB: BomSys_write called"); 2453 2453 + return NULL; 2454 2454 + } 2455 2455 + 2456 2456 + void* _BOMBomPathTreePrint(void) 2457 2457 + { 2458 2458 + if (verbose) puts("STUB: _BOMBomPathTreePrint called"); 2459 2459 + return NULL; 2460 2460 + } 2461 2461 + 2462 2462 + void* _BOMBomPrint(void) 2463 2463 + { 2464 2464 + if (verbose) puts("STUB: _BOMBomPrint called"); 2465 2465 + return NULL; 2466 2466 + } 2467 2467 + 2468 2468 + void* _BOMCFArrayPrint(void) 2469 2469 + { 2470 2470 + if (verbose) puts("STUB: _BOMCFArrayPrint called"); 2471 2471 + return NULL; 2472 2472 + } 2473 2473 + 2474 2474 + void* _BOMExceptionHandlerCall(void) 2475 2475 + { 2476 2476 + if (verbose) puts("STUB: _BOMExceptionHandlerCall called"); 2477 2477 + return NULL; 2478 2478 + } 2479 2479 + 2480 2480 + void* _BOMFatalException(void) 2481 2481 + { 2482 2482 + if (verbose) puts("STUB: _BOMFatalException called"); 2483 2483 + return NULL; 2484 2484 + }

+1

src/frameworks/CMakeLists.txt

reviewed

··· 8 8 add_subdirectory(Automator) 9 9 add_subdirectory(AVFoundation) 10 10 add_subdirectory(AVKit) 11 11 + add_subdirectory(Bom) 11 12 add_subdirectory(CalendarStore) 12 13 add_subdirectory(Carbon) 13 14 add_subdirectory(CloudKit)

+1

src/frameworks/include/Bom

reviewed

··· 1 1 + ../Bom/include/Bom