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
57static 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
84static 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
100static void ReadO65Header (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
146static 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
178static 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
208static 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
273static 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
305static 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
354O65Data* 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
379const 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
392const 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