/*-------------------------------------------------------------------
* XPI Stub Load/Unload
*-------------------------------------------------------------------*/
OSErr
LoadXPIStub(XPI_InitProc* pfnInit, XPI_InstallProc* pfnInstall, XPI_ExitProc* pfnExit,
CFragConnectionID* connID, FSSpec& aTargetDir, Str255 errName)
{
OSErr err;
FSSpec fslib;
Str63 fragName = XPISTUB_DLL;
Ptr mainAddr, symAddr;
CFragSymbolClass symClass;
long tgtDirID;
Boolean isDir;
err = FSpGetDirectoryID( &aTargetDir, &tgtDirID, &isDir );
if (err!=noErr)
return err;
else if (!isDir)
return paramErr;
err = FSMakeFSSpec(aTargetDir.vRefNum, tgtDirID, fragName, &fslib);
if (err!=noErr)
return err;
err = GetDiskFragment(&fslib, 0, kCFragGoesToEOF, nil, /*kPrivateCFragCopy*/kReferenceCFrag, connID, &mainAddr, errName);
if ( err == noErr && *connID != NULL)
{
ERR_CHECK_RET( FindSymbol(*connID, "\pXPI_Init", &symAddr, &symClass), err );
*pfnInit = (XPI_InitProc) symAddr;
ERR_CHECK_RET( FindSymbol(*connID, "\pXPI_Install", &symAddr, &symClass), err);
*pfnInstall = (XPI_InstallProc) symAddr;
ERR_CHECK_RET( FindSymbol(*connID, "\pXPI_Exit", &symAddr, &symClass), err);
*pfnExit = (XPI_ExitProc) symAddr;
}
bool wxDynamicLibrary::Load(const wxString& libnameOrig, int flags)
{
wxASSERT_MSG(m_handle == 0, _T("Library already loaded."));
// add the proper extension for the DLL ourselves unless told not to
wxString libname = libnameOrig;
if ( !(flags & wxDL_VERBATIM) )
{
// and also check that the libname doesn't already have it
wxString ext;
wxFileName::SplitPath(libname, NULL, NULL, &ext);
if ( ext.empty() )
{
libname += GetDllExt();
}
}
// different ways to load a shared library
//
// FIXME: should go to the platform-specific files!
#if defined(__WXMAC__) && !defined(__DARWIN__)
FSSpec myFSSpec;
Ptr myMainAddr;
Str255 myErrName;
wxMacFilename2FSSpec( libname , &myFSSpec );
if( GetDiskFragment( &myFSSpec,
0,
kCFragGoesToEOF,
"\p",
kPrivateCFragCopy,
&m_handle,
&myMainAddr,
myErrName ) != noErr )
{
wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
libname.c_str(),
wxMacMakeStringFromPascal( myErrName ).c_str() );
m_handle = 0;
}
#elif defined(__WXPM__) || defined(__EMX__)
char err[256] = "";
DosLoadModule(err, sizeof(err), (PSZ)libname.c_str(), &m_handle);
#else
m_handle = RawLoad(libname, flags);
#endif
if ( m_handle == 0 )
{
#ifdef wxHAVE_DYNLIB_ERROR
Error();
#else
wxLogSysError(_("Failed to load shared library '%s'"), libname.c_str());
#endif
}
return IsLoaded();
}
/*----------------------------------------------------------------------
Called internally to load a code fragment.
----------------------------------------------------------------------*/
OSErr preloadTransport(StringPtr transportName, CFragConnectionID* connID)
{
OSErr anErr;
FSSpec spec;
Ptr mainAddr;
Str255 errName;
Str255 fragName;
CFragSymbolClass symClass;
// we need to setup our function pointers for the selected
// transport. We do this by looking for a file with a code
// fragment and then we load all of the function pointers
// from it for later use throughout the application
// create a pascal string which is the file name which has the
// fragment in it
anErr = FSMakeFSSpec(gvRef, gparID, transportName, &spec);
if (anErr == noErr) {
anErr = GetDiskFragment(
&spec,
0,
kCFragGoesToEOF,
fragName,
kLoadCFrag,
connID,
&mainAddr,
errName
);
}
return anErr;
}
OSErr NSLoadNamedFragment(const FSSpec *fileSpec, const char* fragmentName, CFragConnectionID *outConnectionID)
{
UInt32 fragOffset, fragLength;
short fragNameLength;
Ptr main;
Str255 fragName;
Str255 errName;
OSErr err;
err = GetNamedFragmentOffsets(fileSpec, fragmentName, &fragOffset, &fragLength);
if (err != noErr) return err;
// convert fragment name to pascal string
fragNameLength = strlen(fragmentName);
if (fragNameLength > 255)
fragNameLength = 255;
BlockMoveData(fragmentName, &fragName[1], fragNameLength);
fragName[0] = fragNameLength;
// Note that we pass the fragment name as the 4th param to GetDiskFragment.
// This value affects the ability of debuggers, and the Talkback system,
// to match code fragments with symbol files
err = GetDiskFragment(fileSpec, fragOffset, fragLength, fragName,
kLoadCFrag, outConnectionID, &main, errName);
return err;
}
static pascal void
GetSharedLibraryFilterProc(const CInfoPBRec* const inCpb, Boolean* inWantQuit, void *inFilterData)
{
GetSharedLibraryFilterProcData* pFilterData = (GetSharedLibraryFilterProcData*) inFilterData;
if ((inCpb->hFileInfo.ioFlAttrib & (1 << ioDirFlg)) == 0)
{
FSSpec fragSpec;
OSErr tempErr;
Str255 errName;
Boolean crap;
UInt32 codeOffset;
UInt32 codeLength;
// it's a file
// ¥ fix-me do we really want to allow all 'APPL's' for in which to find this library?
switch (inCpb->hFileInfo.ioFlFndrInfo.fdType)
{
case kCFragLibraryFileType:
case 'APPL':
tempErr = FSMakeFSSpec(inCpb->hFileInfo.ioVRefNum, inCpb->hFileInfo.ioFlParID, inCpb->hFileInfo.ioNamePtr, &fragSpec);
// this shouldn't fail
if (noErr != tempErr)
{
return;
}
// resolve an alias if this was one
tempErr = ResolveAliasFile(&fragSpec, true, &crap, &crap);
// if got here we have a shlb (or app-like shlb)
if (noErr != tempErr)
{
// probably couldn't resolve an alias
return;
}
break;
default:
return;
}
// see if this symbol is in this fragment
if (LibInPefContainer(&fragSpec, pFilterData->inName, &codeOffset, &codeLength))
tempErr = GetDiskFragment(&fragSpec, codeOffset, codeLength, fragSpec.name, kLoadCFrag, &pFilterData->outID, &pFilterData->outAddress, errName);
else
return;
// stop if we found a library by that name
if (noErr == tempErr)
{
*inWantQuit = true;
pFilterData->outFound = true;
pFilterData->outError = tempErr;
}
}
// FSpIterateDirectory will automagically call us for subsequent sub-dirs if necessary
}
void SetUpQD(void)
{
ProcessSerialNumber PSN;
FSSpec myFSSpec;
Str63 name;
ProcessInfoRec infoRec;
OSErr result = noErr;
CFragConnectionID connID;
Str255 errName;
// Memorize the plugin¹s resource file refnum for later use.
gResFile = CurResFile();
#if !TARGET_API_MAC_CARBON
// Ask the system if CFM is available.
long response;
OSErr err = Gestalt(gestaltCFMAttr, &response);
Boolean hasCFM = BitTst(&response, 31-gestaltCFMPresent);
if (hasCFM) {
// GetProcessInformation takes a process serial number and
// will give us back the name and FSSpec of the application.
// See the Process Manager in IM.
infoRec.processInfoLength = sizeof(ProcessInfoRec);
infoRec.processName = name;
infoRec.processAppSpec = &myFSSpec;
PSN.highLongOfPSN = 0;
PSN.lowLongOfPSN = kCurrentProcess;
result = GetProcessInformation(&PSN, &infoRec);
} else {
// If no CFM installed, assume it must be a 68K app.
result = -1;
}
if (result == noErr) {
// Now that we know the app name and FSSpec, we can call
// GetDiskFragmentto get a connID to use in a subsequent call
// to FindSymbol (it will also return the address of ³main² in
// app, which we ignore). If GetDiskFragment returns an
// error, we assume the app must be 68K.
Ptr mainAddr;
result = GetDiskFragment(infoRec.processAppSpec, 0L, 0L,
infoRec.processName, kReferenceCFrag,
&connID, (Ptr*)&mainAddr, errName);
}
if (result == noErr) {
// The app is a PPC code fragment, so call FindSymbol
// to get the exported ³qd² symbol so we can access its
// QuickDraw globals.
CFragSymbolClass symClass;
result = FindSymbol(connID, "\pqd", (Ptr*)&gQDPtr, &symClass);
} else {
OSErr CallImportPlug( MADLibrary *inMADDriver,
short PlugNo, // CODE du plug
OSType order,
char *AlienFile,
MADMusic *theNewMAD,
PPInfoRec *info)
{
OSErr myErr;
short fileID = 0;
MADDriverSettings driverSettings;
CFragConnectionID connID;
Ptr mainAddr;
Str255 errName;
static OSErr (*mainPLUG)( OSType, char*, MADMusic*, PPInfoRec*, MADDriverSettings *);
driverSettings.sysMemory = false;
if( !EqualString( RSRCNAME, inMADDriver->ThePlug[ PlugNo].file.name, false, false))
{
fileID = FSpOpenResFile( &inMADDriver->ThePlug[ PlugNo].file, fsCurPerm);
UseResFile( fileID);
}
myErr = GetDiskFragment( &inMADDriver->ThePlug[ PlugNo].file, 0, kCFragGoesToEOF, inMADDriver->ThePlug[ PlugNo].file.name, kLoadCFrag, &connID, (Ptr *) &mainPLUG, errName);
if( myErr == noErr)
{
myErr = mainPLUG ( order, AlienFile, theNewMAD, info, &driverSettings);
// DisposePtr( (Ptr) mainPLUG);
CloseConnection( &connID);
}
// myErr = TESTmain( order, AlienFile, theNewMAD, info, &driverSettings);
if( !EqualString( RSRCNAME, inMADDriver->ThePlug[ PlugNo].file.name, false, false))
CloseResFile( fileID);
// theNewMAD->currentDriver = NULL;
return( myErr);
}
OSErr NSLoadIndexedFragment(const FSSpec *fileSpec, PRUint32 fragmentIndex,
char** outFragName, CFragConnectionID *outConnectionID)
{
UInt32 fragOffset, fragLength;
char *fragNameBlock = NULL;
Ptr main;
Str255 fragName = "\p";
Str255 errName;
OSErr err;
*outFragName = NULL;
err = GetIndexedFragmentOffsets(fileSpec, fragmentIndex, &fragOffset, &fragLength, &fragNameBlock);
if (err != noErr) return err;
if (fragNameBlock)
{
UInt32 nameLen = strlen(fragNameBlock);
if (nameLen > 63)
nameLen = 63;
BlockMoveData(fragNameBlock, &fragName[1], nameLen);
fragName[0] = nameLen;
}
// Note that we pass the fragment name as the 4th param to GetDiskFragment.
// This value affects the ability of debuggers, and the Talkback system,
// to match code fragments with symbol files
err = GetDiskFragment(fileSpec, fragOffset, fragLength, fragName,
kLoadCFrag, outConnectionID, &main, errName);
if (err != noErr)
{
free(fragNameBlock);
return err;
}
*outFragName = fragNameBlock;
return noErr;
}
CFragConnectionID LoadLibViaPath(char *libName, char *pluginDirPath) {
FSSpec fileSpec;
Str255 problemLibName;
char tempDirPath[DOCUMENT_NAME_SIZE+1];
Ptr junk;
CFragConnectionID libHandle = 0;
OSErr err = noErr;
strncpy(tempDirPath,pluginDirPath,DOCUMENT_NAME_SIZE);
if (tempDirPath[strlen(tempDirPath)-1] != DELIMITER)
strcat(tempDirPath,DELIMITER);
strcat(tempDirPath,libName);
err =makeFSSpec(tempDirPath,&fileSpec);
if (err) return nil; /* bad plugin directory path */
err = GetDiskFragment(
&fileSpec, 0, kCFragGoesToEOF, nil, kLoadCFrag, &libHandle, &junk, problemLibName);
if (err)
return nil;
return libHandle;
}
/*----------------------------------------------------------------------
Called internally to load a code fragment.
----------------------------------------------------------------------*/
OSErr LoadTransport(char *transportName)
{
Str255 pTransportName;
OSErr anErr;
FSSpec spec;
Ptr mainAddr;
Str255 errName;
SymClass symClass;
SetBasePath();
// we need to setup our function pointers for the selected
// transport. We do this by looking for a file with a code
// fragment and then we load all of the function pointers
// from it for later use throughout the application
// create a pascal string which is the file name which has the
// fragment in it
strcpy((char*) pTransportName, transportName);
c2pstr((char*) pTransportName);
anErr = FSMakeFSSpec(gvRef, gparID, pTransportName, &spec); if (anErr == noErr) {
anErr = GetDiskFragment(
&spec,
0,
kCFragGoesToEOF,
nil,
kLoadCFrag,
&connID,
&mainAddr,
errName
);
}
return anErr;
}
int
TclLoadFile(
Tcl_Interp *interp, /* Used for error reporting. */
char *fileName, /* Name of the file containing the desired
* code. */
char *sym1, char *sym2, /* Names of two procedures to look up in
* the file's symbol table. */
Tcl_PackageInitProc **proc1Ptr,
Tcl_PackageInitProc **proc2Ptr)
/* Where to return the addresses corresponding
* to sym1 and sym2. */
{
CFragConnectionID connID;
Ptr dummy;
OSErr err;
CFragSymbolClass symClass;
FSSpec fileSpec;
short fragFileRef, saveFileRef;
Handle fragResource;
UInt32 offset = 0;
UInt32 length = kCFragGoesToEOF;
char packageName[255];
Str255 errName;
/*
* First thing we must do is infer the package name from the sym1
* variable. This is kind of dumb since the caller actually knows
* this value, it just doesn't give it to us.
*/
strcpy(packageName, sym1);
*packageName = (char) tolower(*packageName);
packageName[strlen(packageName) - 5] = NULL;
err = FSpLocationFromPath(strlen(fileName), fileName, &fileSpec);
if (err != noErr) {
interp->result = "could not locate shared library";
return TCL_ERROR;
}
/*
* See if this fragment has a 'cfrg' resource. It will tell us were
* to look for the fragment in the file. If it doesn't exist we will
* assume we have a ppc frag using the whole data fork. If it does
* exist we find the frag that matches the one we are looking for and
* get the offset and size from the resource.
*/
saveFileRef = CurResFile();
SetResLoad(false);
fragFileRef = FSpOpenResFile(&fileSpec, fsRdPerm);
SetResLoad(true);
if (fragFileRef != -1) {
UseResFile(fragFileRef);
fragResource = Get1Resource(kCFragResourceType, kCFragResourceID);
HLock(fragResource);
if (ResError() == noErr) {
CfrgItem* srcItem;
long itemCount, index;
Ptr itemStart;
itemCount = (*(CfrgHeaderPtrHand)fragResource)->itemCount;
itemStart = &(*(CfrgHeaderPtrHand)fragResource)->arrayStart;
for (index = 0; index < itemCount;
index++, itemStart += srcItem->itemSize) {
srcItem = (CfrgItem*)itemStart;
if (srcItem->archType != OUR_ARCH_TYPE) continue;
if (!strncasecmp(packageName, (char *) srcItem->name + 1,
srcItem->name[0])) {
offset = srcItem->codeOffset;
length = srcItem->codeLength;
}
}
}
/*
* Close the resource file. If the extension wants to reopen the
* resource fork it should use the tclMacLibrary.c file during it's
* construction.
*/
HUnlock(fragResource);
ReleaseResource(fragResource);
CloseResFile(fragFileRef);
UseResFile(saveFileRef);
}
/*
* Now we can attempt to load the fragement using the offset & length
* obtained from the resource. We don't worry about the main entry point
* as we are going to search for specific entry points passed to us.
*/
c2pstr(packageName);
err = GetDiskFragment(&fileSpec, offset, length, (StringPtr) packageName,
kLoadCFrag, &connID, &dummy, errName);
if (err != fragNoErr) {
p2cstr(errName);
Tcl_AppendResult(interp, "couldn't load file \"", fileName,
"\": ", errName, (char *) NULL);
return TCL_ERROR;
}
c2pstr(sym1);
err = FindSymbol(connID, (StringPtr) sym1, (Ptr *) proc1Ptr, &symClass);
p2cstr((StringPtr) sym1);
if (err != fragNoErr || symClass == kDataCFragSymbol) {
interp->result =
"could not find Initialization routine in library";
return TCL_ERROR;
}
c2pstr(sym2);
err = FindSymbol(connID, (StringPtr) sym2, (Ptr *) proc2Ptr, &symClass);
p2cstr((StringPtr) sym2);
if (err != fragNoErr || symClass == kDataCFragSymbol) {
*proc2Ptr = NULL;
}
return TCL_OK;
}
OSErr WebGetDiskFragment(const FSSpec *fileSpec, UInt32 offset, UInt32 length, ConstStr63Param fragName, CFragLoadOptions options, CFragConnectionID *connID, Ptr *mainAddr, Str255 errMessage)
{
return GetDiskFragment(fileSpec, offset, length, fragName, options, connID, mainAddr, errMessage);
}
