1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
/*
* tclLoadMac.c --
*
* This procedure provides a version of the dlopen() function for use
* on the Macintosh. This procedure will only work with systems
* that use the Code Fragment Manager.
*
* Adapted from tclMacLoad.c in the Tcl 8.0p2 distribution.
*/
#include <CodeFragments.h>
#include <Errors.h>
#include <Resources.h>
#include <Strings.h>
#include <FSpCompat.h>
/*
* Seems that the 3.0.1 Universal headers leave this define out. So we
* define it here...
*/
#ifndef fragNoErr
# define fragNoErr noErr
#endif
#include "tcl.h"
#include "compat:dlfcn.h"
#if GENERATINGPOWERPC
# define OUR_ARCH_TYPE kPowerPCCFragArch
#else
# define OUR_ARCH_TYPE kMotorola68KCFragArch
#endif
/*
* The following data structure defines the structure of a code fragment
* resource. We can cast the resource to be of this type to access
* any fields we need to see.
*/
struct CfrgHeader {
long res1;
long res2;
long version;
long res3;
long res4;
long filler1;
long filler2;
long itemCount;
char arrayStart; /* Array of externalItems begins here. */
};
typedef struct CfrgHeader CfrgHeader, *CfrgHeaderPtr, **CfrgHeaderPtrHand;
/*
* The below structure defines a cfrag item within the cfrag resource.
*/
struct CfrgItem {
OSType archType;
long updateLevel;
long currVersion;
long oldDefVersion;
long appStackSize;
short appSubFolder;
char usage;
char location;
long codeOffset;
long codeLength;
long res1;
long res2;
short itemSize;
Str255 name; /* This is actually variable sized. */
};
typedef struct CfrgItem CfrgItem;
/*
*----------------------------------------------------------------------
*
* dlopen --
*
* This function is an implementation of dlopen() for the Mac.
*
* Results:
* Returns the handle of the newly loaded library, or NULL on
* failure.
*
* Side effects:
* Loads the specified library into the process.
*
*----------------------------------------------------------------------
*/
static Str255 errName;
void *
dlopen(path, mode)
const char *path;
int mode;
{
CFragConnectionID connID;
Ptr dummy;
OSErr err;
FSSpec fileSpec;
short fragFileRef, saveFileRef;
Handle fragResource;
UInt32 offset = 0;
UInt32 length = kCFragGoesToEOF;
char packageName[255];
const char* pkgGuess;
char* p;
/*
* First thing we must do is infer the package name from the file
* name. This is kind of dumb since the caller actually knows
* this value, it just doesn't give it to us.
*/
if ((pkgGuess = strrchr(path,':')) != NULL) {
pkgGuess++;
} else {
pkgGuess = path;
}
if (!strncmp(pkgGuess,"lib",3)) {
pkgGuess+=3;
}
strcpy(packageName,pkgGuess);
p = packageName;
if ((*p) && islower(UCHAR(*p++))) {
packageName[0] = (char) toupper(UCHAR(packageName[0]));
}
while (isalpha(UCHAR(*p)) || (*p == '_')) {
if (isupper(UCHAR(*p))) {
*p = (char) tolower(UCHAR(*p));
}
p++;
}
*p = 0;
err = FSpLocationFromPath(strlen(path), (char *) path, &fileSpec);
if (err != noErr) {
strcpy((char *) errName, "file not found");
return (void *) NULL;
}
/*
* 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);
return (void *) NULL;
}
return (void *) connID;
}
/*
*----------------------------------------------------------------------
*
* dlsym --
*
* This function is an alternative for the system function
* GetProcAddress. It returns the address of a
* symbol, give the handle returned by dlopen().
*
* Results:
* Returns the address of the symbol in the dll.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
void *
dlsym(handle, symbol)
void *handle;
const char *symbol;
{
void *procPtr;
char sym1[255];
OSErr err;
SymClass symClass;
strcpy(sym1, symbol);
c2pstr(sym1);
err = FindSymbol((ConnectionID) handle, (StringPtr) sym1,
(Ptr *) &procPtr, &symClass);
if (err != fragNoErr || symClass == kDataCFragSymbol) {
procPtr = (void *) NULL;
}
return procPtr;
}
/*
*----------------------------------------------------------------------
*
* dlerror --
*
* This function returns a string describing the error which
* occurred in dlopen().
*
* Results:
* Returns an error message.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
char *
dlerror()
{
return (char *) errName;
}
/*
*----------------------------------------------------------------------
*
* dlclose --
*
* Not implemented yet.
*
* Results:
* Always returns 0 (= O.K.)
*
* Side effects:
* None
*
*----------------------------------------------------------------------
*/
int
dlclose(handle)
void *handle;
{
return 0;
}
|
