1 | /*****************************************************************************/ |
2 | /* */ |
3 | /* o65.h */ |
4 | /* */ |
5 | /* Definitions and code for the o65 file format */ |
6 | /* */ |
7 | /* */ |
8 | /* */ |
9 | /* (C) 2002-2004 Ullrich von Bassewitz */ |
10 | /* Roemerstrasse 52 */ |
11 | /* D-70794 Filderstadt */ |
12 | /* EMail: uz@cc65.org */ |
13 | /* */ |
14 | /* */ |
15 | /* This software is provided 'as-is', without any expressed or implied */ |
16 | /* warranty. In no event will the authors be held liable for any damages */ |
17 | /* arising from the use of this software. */ |
18 | /* */ |
19 | /* Permission is granted to anyone to use this software for any purpose, */ |
20 | /* including commercial applications, and to alter it and redistribute it */ |
21 | /* freely, subject to the following restrictions: */ |
22 | /* */ |
23 | /* 1. The origin of this software must not be misrepresented; you must not */ |
24 | /* claim that you wrote the original software. If you use this software */ |
25 | /* in a product, an acknowledgment in the product documentation would be */ |
26 | /* appreciated but is not required. */ |
27 | /* 2. Altered source versions must be plainly marked as such, and must not */ |
28 | /* be misrepresented as being the original software. */ |
29 | /* 3. This notice may not be removed or altered from any source */ |
30 | /* distribution. */ |
31 | /* */ |
32 | /*****************************************************************************/ |
33 | |
34 | |
35 | |
36 | #include <stdio.h> |
37 | #include <string.h> |
38 | #include <errno.h> |
39 | |
40 | /* common */ |
41 | #include "chartype.h" |
42 | #include "xmalloc.h" |
43 | |
44 | /* co65 */ |
45 | #include "error.h" |
46 | #include "fileio.h" |
47 | #include "o65.h" |
48 | |
49 | |
50 | |
51 | /*****************************************************************************/ |
52 | /* struct O65Data */ |
53 | /*****************************************************************************/ |
54 | |
55 | |
56 | |
57 | static O65Data* NewO65Data (void) |
58 | /* Create, initialize and return a new O65Data struct */ |
59 | { |
60 | /* Allocate memory */ |
61 | O65Data* D = xmalloc (sizeof (O65Data)); |
62 | |
63 | /* Initialize the fields as needed */ |
64 | D->Options = AUTO_COLLECTION_INITIALIZER; |
65 | D->Text = 0; |
66 | D->Data = 0; |
67 | D->TextReloc = AUTO_COLLECTION_INITIALIZER; |
68 | D->DataReloc = AUTO_COLLECTION_INITIALIZER; |
69 | D->Imports = AUTO_COLLECTION_INITIALIZER; |
70 | D->Exports = AUTO_COLLECTION_INITIALIZER; |
71 | |
72 | /* Return the new struct */ |
73 | return D; |
74 | } |
75 | |
76 | |
77 | |
78 | /*****************************************************************************/ |
79 | /* Code */ |
80 | /*****************************************************************************/ |
81 | |
82 | |
83 | |
84 | static unsigned long ReadO65Size (FILE* F, const O65Header* H) |
85 | /* Read a size variable (16 or 32 bit, depending on the mode word in the |
86 | ** header) from the o65 file. |
87 | */ |
88 | { |
89 | unsigned long Size = 0; /* Initialize to avoid warnings */ |
90 | switch (H->mode & O65_SIZE_MASK) { |
91 | case O65_SIZE_32BIT: Size = Read32 (F); break; |
92 | case O65_SIZE_16BIT: Size = Read16 (F); break; |
93 | default: Internal ("Invalid size field value in o65 header" ); |
94 | } |
95 | return Size; |
96 | } |
97 | |
98 | |
99 | |
100 | static void (FILE* F, O65Header* H) |
101 | /* Read an o65 header from the given file. The function will call Error if |
102 | ** something is wrong. |
103 | */ |
104 | { |
105 | static const char Magic[3] = { |
106 | O65_MAGIC_0, O65_MAGIC_1, O65_MAGIC_2 /* "o65" */ |
107 | }; |
108 | |
109 | /* Read the marker and check it */ |
110 | ReadData (F, H->marker, sizeof (H->marker)); |
111 | if (H->marker[0] != O65_MARKER_0 || H->marker[1] != O65_MARKER_1) { |
112 | Error ("Not an o65 object file: Invalid marker %02X %02X" , |
113 | H->marker[0], H->marker[1]); |
114 | } |
115 | |
116 | /* Read the magic and check it */ |
117 | ReadData (F, H->magic, sizeof (H->magic)); |
118 | if (memcmp (H->magic, Magic, sizeof (H->magic)) != 0) { |
119 | Error ("Not an o65 object file: Invalid magic %02X %02X %02X" , |
120 | H->magic[0], H->magic[1], H->magic[2]); |
121 | } |
122 | |
123 | /* Read the version number and check it */ |
124 | H->version = Read8 (F); |
125 | if (H->version != O65_VERSION) { |
126 | Error ("Invalid o65 version number: %02X" , H->version); |
127 | } |
128 | |
129 | /* Read the mode word */ |
130 | H->mode = Read16 (F); |
131 | |
132 | /* Read the remainder of the header */ |
133 | H->tbase = ReadO65Size (F, H); |
134 | H->tlen = ReadO65Size (F, H); |
135 | H->dbase = ReadO65Size (F, H); |
136 | H->dlen = ReadO65Size (F, H); |
137 | H->bbase = ReadO65Size (F, H); |
138 | H->blen = ReadO65Size (F, H); |
139 | H->zbase = ReadO65Size (F, H); |
140 | H->zlen = ReadO65Size (F, H); |
141 | H->stack = ReadO65Size (F, H); |
142 | } |
143 | |
144 | |
145 | |
146 | static O65Option* ReadO65Option (FILE* F) |
147 | /* Read the next O65 option from the given file. The option is stored into a |
148 | ** dynamically allocated O65Option struct which is returned. On end of options, |
149 | ** NULL is returned. On error, Error is called which terminates the program. |
150 | */ |
151 | { |
152 | O65Option* O; |
153 | |
154 | /* Read the length of the option and bail out on end of options */ |
155 | unsigned char Len = Read8 (F); |
156 | if (Len == 0) { |
157 | return 0; |
158 | } |
159 | if (Len < 2) { |
160 | Error ("Found option with length < 2 (input file corrupt)" ); |
161 | } |
162 | Len -= 2; |
163 | |
164 | /* Allocate a new O65Option structure of the needed size */ |
165 | O = xmalloc (sizeof (*O) - sizeof (O->Data) + Len); |
166 | |
167 | /* Assign the length and read the remaining option data */ |
168 | O->Len = Len; |
169 | O->Type = Read8 (F); |
170 | ReadData (F, O->Data, Len); |
171 | |
172 | /* Return the new struct */ |
173 | return O; |
174 | } |
175 | |
176 | |
177 | |
178 | static O65Import* ReadO65Import (FILE* F) |
179 | /* Read an o65 import from the file */ |
180 | { |
181 | O65Import* I; |
182 | |
183 | /* Allow identifiers up to 511 bytes */ |
184 | char Buf[512]; |
185 | |
186 | /* Read the identifier */ |
187 | unsigned Len = 0; |
188 | char C; |
189 | do { |
190 | C = Read8 (F); |
191 | if (Len >= sizeof (Buf)) { |
192 | Error ("Imported identifier exceeds maximum size (%u)" , |
193 | (unsigned) sizeof (Buf)); |
194 | } |
195 | Buf[Len++] = C; |
196 | } while (C != '\0'); |
197 | |
198 | /* Allocate an import structure and initialize it */ |
199 | I = xmalloc (sizeof (*I) - sizeof (I->Name) + Len); |
200 | memcpy (I->Name, Buf, Len); |
201 | |
202 | /* Return the new struct */ |
203 | return I; |
204 | } |
205 | |
206 | |
207 | |
208 | static void ReadO65RelocInfo (FILE* F, const O65Data* D, Collection* Reloc) |
209 | /* Read relocation data for one segment */ |
210 | { |
211 | /* Relocation starts at (start address - 1) */ |
212 | unsigned long Offs = (unsigned long) -1L; |
213 | |
214 | while (1) { |
215 | |
216 | O65Reloc* R; |
217 | |
218 | /* Read the next relocation offset */ |
219 | unsigned char C = Read8 (F); |
220 | if (C == 0) { |
221 | /* End of relocation table */ |
222 | break; |
223 | } |
224 | |
225 | /* Create a new relocation entry */ |
226 | R = xmalloc (sizeof (*R)); |
227 | |
228 | /* Handle overflow bytes */ |
229 | while (C == 0xFF) { |
230 | Offs += 0xFE; |
231 | C = Read8 (F); |
232 | } |
233 | |
234 | /* Calculate the final offset */ |
235 | R->Offs = (Offs += C); |
236 | |
237 | /* Read typebyte and segment id */ |
238 | C = Read8 (F); |
239 | R->Type = (C & O65_RTYPE_MASK); |
240 | R->SegID = (C & O65_SEGID_MASK); |
241 | |
242 | /* Read an additional relocation value if there is one */ |
243 | R->SymIdx = (R->SegID == O65_SEGID_UNDEF)? ReadO65Size (F, &D->Header) : 0; |
244 | switch (R->Type) { |
245 | |
246 | case O65_RTYPE_HIGH: |
247 | if ((D->Header.mode & O65_RELOC_MASK) == O65_RELOC_BYTE) { |
248 | /* Low byte follows */ |
249 | R->Val = Read8 (F); |
250 | } else { |
251 | /* Low byte is zero */ |
252 | R->Val = 0; |
253 | } |
254 | break; |
255 | |
256 | case O65_RTYPE_SEG: |
257 | /* Low 16 byte of the segment address follow */ |
258 | R->Val = Read16 (F); |
259 | break; |
260 | |
261 | default: |
262 | R->Val = 0; |
263 | break; |
264 | } |
265 | |
266 | /* Insert this relocation entry into the collection */ |
267 | CollAppend (Reloc, R); |
268 | } |
269 | } |
270 | |
271 | |
272 | |
273 | static O65Export* ReadO65Export (FILE* F, const O65Header* H) |
274 | /* Read an o65 export from the file */ |
275 | { |
276 | O65Export* E; |
277 | |
278 | /* Allow identifiers up to 511 bytes */ |
279 | char Buf[512]; |
280 | |
281 | /* Read the identifier */ |
282 | unsigned Len = 0; |
283 | char C; |
284 | do { |
285 | C = Read8 (F); |
286 | if (Len >= sizeof (Buf)) { |
287 | Error ("Exported identifier exceeds maximum size (%u)" , |
288 | (unsigned) sizeof (Buf)); |
289 | } |
290 | Buf[Len++] = C; |
291 | } while (C != '\0'); |
292 | |
293 | /* Allocate an export structure and initialize it */ |
294 | E = xmalloc (sizeof (*E) - sizeof (E->Name) + Len); |
295 | memcpy (E->Name, Buf, Len); |
296 | E->SegID = Read8 (F); |
297 | E->Val = ReadO65Size (F, H); |
298 | |
299 | /* Return the new struct */ |
300 | return E; |
301 | } |
302 | |
303 | |
304 | |
305 | static O65Data* ReadO65Data (FILE* F) |
306 | /* Read a complete o65 file into dynamically allocated memory and return the |
307 | ** created O65Data struct. |
308 | */ |
309 | { |
310 | unsigned long Count; |
311 | O65Option* O; |
312 | |
313 | /* Create the struct we're going to return */ |
314 | O65Data* D = NewO65Data (); |
315 | |
316 | /* Read the header */ |
317 | ReadO65Header (F, &D->Header); |
318 | |
319 | /* Read the options */ |
320 | while ((O = ReadO65Option (F)) != 0) { |
321 | CollAppend (&D->Options, O); |
322 | } |
323 | |
324 | /* Allocate space for the text segment and read it */ |
325 | D->Text = xmalloc (D->Header.tlen); |
326 | ReadData (F, D->Text, D->Header.tlen); |
327 | |
328 | /* Allocate space for the data segment and read it */ |
329 | D->Data = xmalloc (D->Header.dlen); |
330 | ReadData (F, D->Data, D->Header.dlen); |
331 | |
332 | /* Read the undefined references list */ |
333 | Count = ReadO65Size (F, &D->Header); |
334 | while (Count--) { |
335 | CollAppend (&D->Imports, ReadO65Import (F)); |
336 | } |
337 | |
338 | /* Read the relocation tables for text and data segment */ |
339 | ReadO65RelocInfo (F, D, &D->TextReloc); |
340 | ReadO65RelocInfo (F, D, &D->DataReloc); |
341 | |
342 | /* Read the exported globals list */ |
343 | Count = ReadO65Size (F, &D->Header); |
344 | while (Count--) { |
345 | CollAppend (&D->Exports, ReadO65Export (F, &D->Header)); |
346 | } |
347 | |
348 | /* Return the o65 data read from the file */ |
349 | return D; |
350 | } |
351 | |
352 | |
353 | |
354 | O65Data* ReadO65File (const char* Name) |
355 | /* Read a complete o65 file into dynamically allocated memory and return the |
356 | ** created O65Data struct. |
357 | */ |
358 | { |
359 | O65Data* D; |
360 | |
361 | /* Open the o65 input file */ |
362 | FILE* F = fopen (Name, "rb" ); |
363 | if (F == 0) { |
364 | Error ("Cannot open '%s': %s" , Name, strerror (errno)); |
365 | } |
366 | |
367 | /* Read the file data */ |
368 | D = ReadO65Data (F); |
369 | |
370 | /* Close the input file. Ignore errors since we were only reading */ |
371 | fclose (F); |
372 | |
373 | /* Return the data read */ |
374 | return D; |
375 | } |
376 | |
377 | |
378 | |
379 | const char* GetO65OSName (unsigned char OS) |
380 | /* Return the name of the operating system given by OS */ |
381 | { |
382 | switch (OS) { |
383 | case O65_OS_OSA65: return "OS/A65" ; |
384 | case O65_OS_LUNIX: return "Lunix" ; |
385 | case O65_OS_CC65_MODULE: return "cc65 module" ; |
386 | default: return "unknown" ; |
387 | } |
388 | } |
389 | |
390 | |
391 | |
392 | const char* GetO65OptionText (const O65Option* O) |
393 | /* Return the data of the given option as a readable text. The function returns |
394 | ** a pointer to a static buffer that is reused on the next call, so if in doubt, |
395 | ** make a copy (and no, the function is not thread safe). |
396 | */ |
397 | { |
398 | static char Buf[256]; |
399 | unsigned I, J; |
400 | |
401 | /* Get the length of the text */ |
402 | unsigned Len = 0; |
403 | while (Len < O->Len && O->Data[Len] != '\0') { |
404 | ++Len; |
405 | } |
406 | |
407 | /* Copy into the buffer converting non readable characters */ |
408 | I = J = 0; |
409 | while (I < sizeof (Buf) - 1 && J < Len) { |
410 | if (!IsControl (O->Data[J])) { |
411 | Buf[I++] = O->Data[J]; |
412 | } else { |
413 | Buf[I++] = '\\'; |
414 | if (I >= sizeof (Buf) - 4) { |
415 | --I; |
416 | break; |
417 | } |
418 | switch (O->Data[J]) { |
419 | case '\t': Buf[I++] = 't'; break; |
420 | case '\b': Buf[I++] = 'b'; break; |
421 | case '\n': Buf[I++] = 'n'; break; |
422 | case '\r': Buf[I++] = 'r'; break; |
423 | case '\v': Buf[I++] = 'v'; break; |
424 | default: |
425 | sprintf (Buf + I, "x%02X" , O->Data[J]); |
426 | I += 3; |
427 | break; |
428 | } |
429 | } |
430 | ++J; |
431 | } |
432 | |
433 | /* Terminate the string and return it */ |
434 | Buf[I] = '\0'; |
435 | return Buf; |
436 | } |
437 | |