← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/tcc/oneiric

« back to all changes in this revision

Viewing changes to tiny_impdef.c

  • Committer: Bazaar Package Importer
  • Author(s): Thomas Preud'homme, Aurélien GÉRÔME, Thomas Preud'homme
  • Date: 2008-06-16 03:31:38 UTC
  • mfrom: (1.1.4 upstream) (3.1.2 lenny)
  • Revision ID: james.westby@ubuntu.com-20080616033138-hqo92o7adc6nn9fa
Tags: 0.9.24-1
http://bugs.debian.org/278698
http://bugs.debian.org/304082
http://bugs.debian.org/474883
[ Aurélien GÉRÔME ]
* Change my email address in the Maintainer field.
* Bump Standards-Version to 3.8.0.
* Remove no longer used XS-Vcs-Git and XS-Vcs-Browser fields.
* Add the DM-Upload-Allowed field for Arthur.

[ Thomas Preud'homme ]
* New Upstream Version
  - tcc now supports typename as structure field name (closes: #278698)
  - A long long value used as a test expression ignores the
    upper 32 bits at runtime (closes: #304082)
* Remove unecessary patches:
  - 352202_fix_int_overflow.diff
  - 283066_add_va_copy_define.diff (already disabled)
  - 430209_fix_bound_check_error.diff
* Clean all patches (no fuzz or offset problem anymore)
* Add patch from Bradley Smith to allow compilation with gcc 4.3
  (closes: #474883)
* Add tcc-doc_texi_formatting.diff to correct formatting of tcc-doc.texi

Show diffs side-by-side

added added

removed removed

Lines of Context:
tiny_impdef.c
1
 
/* -------------------------------------------------------------- */
2
 
/*
3
 
        "tiny_impdef creates a .def file from a dll"
4
 
 
5
 
        "Usage: tiny_impdef [-p] <library.dll> [-o outputfile]"
6
 
        "Options:"
7
 
        " -p print to stdout"
8
 
*/
9
 
 
10
 
#include <windows.h>
11
 
#include <stdio.h>
12
 
 
13
 
/* Offset to PE file signature                              */
14
 
#define NTSIGNATURE(a) ((LPVOID)((BYTE *)a                +  \
15
 
                                                ((PIMAGE_DOS_HEADER)a)->e_lfanew))
16
 
 
17
 
/* MS-OS header identifies the NT PEFile signature dword;
18
 
   the PEFILE header exists just after that dword.           */
19
 
#define PEFHDROFFSET(a) ((LPVOID)((BYTE *)a               +  \
20
 
                                                 ((PIMAGE_DOS_HEADER)a)->e_lfanew +  \
21
 
                                                         SIZE_OF_NT_SIGNATURE))
22
 
 
23
 
/* PE optional header is immediately after PEFile header.    */
24
 
#define OPTHDROFFSET(a) ((LPVOID)((BYTE *)a               +  \
25
 
                                                 ((PIMAGE_DOS_HEADER)a)->e_lfanew +  \
26
 
                                                   SIZE_OF_NT_SIGNATURE           +  \
27
 
                                                   sizeof (IMAGE_FILE_HEADER)))
28
 
 
29
 
/* Section headers are immediately after PE optional header. */
30
 
#define SECHDROFFSET(a) ((LPVOID)((BYTE *)a               +  \
31
 
                                                 ((PIMAGE_DOS_HEADER)a)->e_lfanew +  \
32
 
                                                   SIZE_OF_NT_SIGNATURE           +  \
33
 
                                                   sizeof (IMAGE_FILE_HEADER)     +  \
34
 
                                                   sizeof (IMAGE_OPTIONAL_HEADER)))
35
 
 
36
 
 
37
 
#define SIZE_OF_NT_SIGNATURE 4
38
 
 
39
 
/* -------------------------------------------------------------- */
40
 
 
41
 
int   WINAPI NumOfSections (
42
 
        LPVOID    lpFile)
43
 
{
44
 
        /* Number of sections is indicated in file header. */
45
 
        return (int)
46
 
                ((PIMAGE_FILE_HEADER)
47
 
                        PEFHDROFFSET(lpFile))->NumberOfSections;
48
 
}
49
 
 
50
 
 
51
 
/* -------------------------------------------------------------- */
52
 
 
53
 
LPVOID  WINAPI ImageDirectoryOffset (
54
 
                LPVOID    lpFile,
55
 
                DWORD     dwIMAGE_DIRECTORY)
56
 
{
57
 
        PIMAGE_OPTIONAL_HEADER   poh;
58
 
        PIMAGE_SECTION_HEADER    psh;
59
 
        int                      nSections = NumOfSections (lpFile);
60
 
        int                      i = 0;
61
 
        LPVOID                   VAImageDir;
62
 
 
63
 
        /* Retrieve offsets to optional and section headers. */
64
 
        poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (lpFile);
65
 
        psh = (PIMAGE_SECTION_HEADER)SECHDROFFSET (lpFile);
66
 
 
67
 
        /* Must be 0 thru (NumberOfRvaAndSizes-1). */
68
 
        if (dwIMAGE_DIRECTORY >= poh->NumberOfRvaAndSizes)
69
 
                return NULL;
70
 
 
71
 
        /* Locate image directory's relative virtual address. */
72
 
        VAImageDir = (LPVOID)poh->DataDirectory
73
 
                                           [dwIMAGE_DIRECTORY].VirtualAddress;
74
 
 
75
 
        /* Locate section containing image directory. */
76
 
        while (i++<nSections)
77
 
                {
78
 
                if (psh->VirtualAddress <= (DWORD)VAImageDir
79
 
                 && psh->VirtualAddress + psh->SizeOfRawData > (DWORD)VAImageDir)
80
 
                        break;
81
 
                psh++;
82
 
                }
83
 
 
84
 
        if (i > nSections)
85
 
                return NULL;
86
 
 
87
 
        /* Return image import directory offset. */
88
 
        return (LPVOID)(((int)lpFile +
89
 
                                         (int)VAImageDir - psh->VirtualAddress) +
90
 
                                        (int)psh->PointerToRawData);
91
 
}
92
 
 
93
 
/* -------------------------------------------------------------- */
94
 
 
95
 
BOOL    WINAPI GetSectionHdrByName (
96
 
        LPVOID                   lpFile,
97
 
        IMAGE_SECTION_HEADER     *sh,
98
 
        char                     *szSection)
99
 
{
100
 
        PIMAGE_SECTION_HEADER    psh;
101
 
        int                      nSections = NumOfSections (lpFile);
102
 
        int                      i;
103
 
 
104
 
        if ((psh = (PIMAGE_SECTION_HEADER)SECHDROFFSET (lpFile)) !=
105
 
                 NULL)
106
 
                {
107
 
                /* find the section by name */
108
 
                for (i=0; i<nSections; i++)
109
 
                        {
110
 
                        if (!strcmp (psh->Name, szSection))
111
 
                                {
112
 
                                /* copy data to header */
113
 
                                memcpy ((LPVOID)sh,
114
 
                                                        (LPVOID)psh,
115
 
                                                        sizeof (IMAGE_SECTION_HEADER));
116
 
                                return TRUE;
117
 
                                }
118
 
                        else
119
 
                                psh++;
120
 
                        }
121
 
                }
122
 
 
123
 
        return FALSE;
124
 
}
125
 
 
126
 
/* -------------------------------------------------------------- */
127
 
 
128
 
BOOL    WINAPI GetSectionHdrByAddress (
129
 
        LPVOID                   lpFile,
130
 
        IMAGE_SECTION_HEADER     *sh,
131
 
        DWORD                    addr)
132
 
{
133
 
        PIMAGE_SECTION_HEADER    psh;
134
 
        int                      nSections = NumOfSections (lpFile);
135
 
        int                      i;
136
 
 
137
 
        if ((psh = (PIMAGE_SECTION_HEADER)SECHDROFFSET (lpFile)) !=
138
 
                 NULL)
139
 
                {
140
 
                /* find the section by name */
141
 
                for (i=0; i<nSections; i++)
142
 
                        {
143
 
                        if (addr >= psh->VirtualAddress && addr < psh->VirtualAddress + psh->SizeOfRawData)
144
 
                                {
145
 
                                /* copy data to header */
146
 
                                memcpy ((LPVOID)sh,
147
 
                                                        (LPVOID)psh,
148
 
                                                        sizeof (IMAGE_SECTION_HEADER));
149
 
                                return TRUE;
150
 
                                }
151
 
                        else
152
 
                                psh++;
153
 
                        }
154
 
                }
155
 
 
156
 
        return FALSE;
157
 
}
158
 
 
159
 
/* -------------------------------------------------------------- */
160
 
 
161
 
int  WINAPI GetExportFunctionNames (
162
 
        LPVOID    lpFile,
163
 
        HANDLE    hHeap,
164
 
        char      **pszFunctions)
165
 
{
166
 
        IMAGE_SECTION_HEADER       sh;
167
 
        PIMAGE_EXPORT_DIRECTORY    ped;
168
 
        int                        *pNames, *pCnt;
169
 
        char *pSrc, *pDest;
170
 
        int                        i, nCnt;
171
 
        DWORD                      VAImageDir;
172
 
        PIMAGE_OPTIONAL_HEADER     poh;
173
 
        char *pOffset;
174
 
 
175
 
        /* Get section header and pointer to data directory
176
 
           for .edata section. */
177
 
        if ((ped = (PIMAGE_EXPORT_DIRECTORY)ImageDirectoryOffset
178
 
                        (lpFile, IMAGE_DIRECTORY_ENTRY_EXPORT)) == NULL)
179
 
                return 0;
180
 
 
181
 
        poh = (PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET (lpFile);
182
 
        VAImageDir = poh->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
183
 
 
184
 
        if (FALSE == GetSectionHdrByAddress (lpFile, &sh, VAImageDir)) return 0;
185
 
 
186
 
        pOffset = (char *)lpFile + (sh.PointerToRawData -  sh.VirtualAddress);
187
 
 
188
 
        pNames = (int *)(pOffset + (DWORD)ped->AddressOfNames);
189
 
 
190
 
        /* Figure out how much memory to allocate for all strings. */
191
 
        nCnt = 1;
192
 
        for (i=0, pCnt = pNames; i<(int)ped->NumberOfNames; i++)
193
 
        {
194
 
           pSrc = (pOffset + *pCnt++);
195
 
           if (pSrc) nCnt += strlen(pSrc)+1;
196
 
        }
197
 
 
198
 
        /* Allocate memory off heap for function names. */
199
 
        pDest = *pszFunctions = HeapAlloc (hHeap, HEAP_ZERO_MEMORY, nCnt);
200
 
 
201
 
        /* Copy all strings to buffer. */
202
 
        for (i=0, pCnt = pNames; i<(int)ped->NumberOfNames; i++)
203
 
        {
204
 
           pSrc = (pOffset + *pCnt++);
205
 
           if (pSrc) { strcpy(pDest, pSrc); pDest += strlen(pSrc)+1; }
206
 
        }
207
 
        *pDest = 0;
208
 
 
209
 
        return ped->NumberOfNames;
210
 
}
211
 
 
212
 
/* -------------------------------------------------------------- */
213
 
 
214
 
int main(int argc, char **argv)
215
 
{
216
 
 
217
 
        HANDLE hHeap; HANDLE hFile; HANDLE hMapObject; VOID *pMem;
218
 
        int nCnt, ret, argind, std;
219
 
        char *pNames;
220
 
        char infile[MAX_PATH];
221
 
        char buffer[MAX_PATH];
222
 
        char outfile[MAX_PATH];
223
 
        char libname[80];
224
 
 
225
 
        hHeap = NULL;
226
 
        hFile = NULL;
227
 
        hMapObject = NULL;
228
 
        pMem = NULL;
229
 
        infile[0] = 0;
230
 
        outfile[0] = 0;
231
 
        ret = 0;
232
 
        std = 0;
233
 
 
234
 
        for (argind = 1; argind < argc; ++argind)
235
 
        {
236
 
                const char *a = argv[argind];
237
 
                if ('-' == a[0])
238
 
                {
239
 
                        if (0 == strcmp(a, "-p"))
240
 
                                std = 1;
241
 
                        else
242
 
                        if (0 == strcmp(a, "-o"))
243
 
                        {
244
 
                                if (++argind == argc) goto usage;
245
 
                                strcpy(outfile, argv[argind]);
246
 
                        }
247
 
                        else
248
 
                                goto usage;
249
 
                }
250
 
                else
251
 
                if (0 == infile[0])
252
 
                        strcpy(infile, a);
253
 
                else
254
 
                        goto usage;
255
 
        }
256
 
 
257
 
        if (0 == infile[0])
258
 
        {
259
 
usage:
260
 
                fprintf(stderr,
261
 
                        "tiny_impdef creates a .def file from a dll\n"
262
 
                        "Usage: tiny_impdef [-p] <library.dll> [-o outputfile]\n"
263
 
                        "Options:\n"
264
 
                        " -p print to stdout\n"
265
 
                        );
266
 
error:
267
 
                ret = 1;
268
 
                goto the_end;
269
 
        }
270
 
 
271
 
        if (SearchPath(NULL, infile, ".dll", sizeof buffer, buffer, NULL))
272
 
                strcpy(infile, buffer);
273
 
 
274
 
        if (0 == outfile[0])
275
 
        {
276
 
                char *p;
277
 
                p = strrchr(strcpy(outfile, infile), '\\');
278
 
                if (NULL == p)
279
 
                p = strrchr(outfile, '/');
280
 
                if (p) strcpy(outfile, p+1);
281
 
 
282
 
                p = strrchr(outfile, '.');
283
 
                if (NULL == p) p = strchr(outfile, 0);
284
 
                strcpy(p, ".def");
285
 
        }
286
 
 
287
 
        hFile=CreateFile(
288
 
                infile,
289
 
                GENERIC_READ,
290
 
                FILE_SHARE_READ,
291
 
                NULL,
292
 
                OPEN_EXISTING,
293
 
                0,
294
 
                NULL
295
 
                );
296
 
 
297
 
        if (hFile == INVALID_HANDLE_VALUE)
298
 
        {
299
 
                fprintf(stderr, "file not found: %s\n", infile);
300
 
                goto error;
301
 
        }
302
 
 
303
 
        if (!std) printf("--> %s\n", infile);
304
 
 
305
 
        hMapObject = CreateFileMapping(
306
 
                hFile,
307
 
                NULL,
308
 
                PAGE_READONLY,
309
 
                0, 0,
310
 
                NULL
311
 
                );
312
 
 
313
 
        if (NULL == hMapObject)
314
 
        {
315
 
                fprintf(stderr, "could not create file mapping.\n");
316
 
                goto error;
317
 
        }
318
 
 
319
 
        pMem = MapViewOfFile(
320
 
                hMapObject,     // object to map view of
321
 
                FILE_MAP_READ,  // read access
322
 
                0,              // high offset:  map from
323
 
                0,              // low offset:   beginning
324
 
                0);             // default: map entire file
325
 
 
326
 
        if (NULL == pMem)
327
 
        {
328
 
                fprintf(stderr, "could not map view of file.\n");
329
 
                goto error;
330
 
        }
331
 
 
332
 
        hHeap = GetProcessHeap();
333
 
        nCnt = GetExportFunctionNames(pMem, hHeap, &pNames);
334
 
        {
335
 
                FILE *op; char *p; int n;
336
 
                if (!std) printf("<-- %s\n", outfile);
337
 
 
338
 
                if (std)
339
 
                        op = stdout;
340
 
                else
341
 
                        op = fopen(outfile, "wt");
342
 
 
343
 
                if (NULL == op)
344
 
                {
345
 
                        fprintf(stderr, "could not create file: %s\n", outfile);
346
 
                        goto error;
347
 
                }
348
 
 
349
 
                p = strrchr(infile, '\\');
350
 
                if (NULL == p)
351
 
                p = strrchr(infile, '/');
352
 
                if (NULL == p) p = infile; else ++p;
353
 
 
354
 
                fprintf(op, "LIBRARY %s\n\nEXPORTS", p);
355
 
                if (std) fprintf(op, " (%d)", nCnt);
356
 
                fprintf(op, "\n");
357
 
                for (n = 0, p = pNames; n < nCnt; ++n)
358
 
                {
359
 
                        fprintf(op, "%s\n", p);
360
 
                        while (*p++);
361
 
                }
362
 
                if (!std) fclose(op);
363
 
        }
364
 
 
365
 
the_end:
366
 
        if (pMem) UnmapViewOfFile(pMem);
367
 
        if (hMapObject) CloseHandle(hMapObject);
368
 
        if (hFile) CloseHandle(hFile);
369
 
        return ret;
370
 
}
371
 
/* -------------------------------------------------------------- */
372