Mercurial > hg-old > index.cgi
view lwlink/readfiles.c @ 169:99300be2d3bd
Allow lines starting with # to be ignored
author | lost |
---|---|
date | Sun, 08 Feb 2009 03:00:44 +0000 |
parents | 106c2fe3c9d9 |
children | d610b8aef91b |
line wrap: on
line source
/* readfiles.c Copyright © 2009 William Astle This file is part of LWLINK. LWLINK is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. Reads input files */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include <argp.h> #include <errno.h> #include <stdio.h> #include <stdlib.h> #include "lwlink.h" #include "util.h" void read_lwobj16v0(fileinfo_t *fn); /* The logic of reading the entire file into memory is simple. All the symbol names in the file are NUL terminated strings and can be used directly without making additional copies. */ void read_files(void) { int i; long size; FILE *f; long bread; for (i = 0; i < ninputfiles; i++) { f = fopen(inputfiles[i] -> filename, "rb"); if (!f) { fprintf(stderr, "Can't open file %s:", inputfiles[i] -> filename); perror(""); exit(1); } fseek(f, 0, SEEK_END); size = ftell(f); rewind(f); inputfiles[i] -> filedata = lw_malloc(size); inputfiles[i] -> filesize = size; bread = fread(inputfiles[i] -> filedata, 1, size, f); if (bread < size) { fprintf(stderr, "Short read on file %s (%ld/%ld):", inputfiles[i] -> filename, bread, size); perror(""); exit(1); } fclose(f); if (!memcmp(inputfiles[i] -> filedata, "LWOBJ16", 8)) { // read v0 LWOBJ16 file read_lwobj16v0(inputfiles[i]); } else { fprintf(stderr, "%s: unknown file format\n", inputfiles[i] -> filename); exit(1); } } } // this macro is used to bail out if we run off the end of the file data // while parsing - it keeps the code below cleaner #define NEXTBYTE() do { cc++; if (cc > fn -> filesize) { fprintf(stderr, "%s: invalid file format\n", fn -> filename); exit(1); } } while (0) // this macro is used to refer to the current byte in the stream #define CURBYTE() (fn -> filedata[cc < fn -> filesize ? cc : fn -> filesize - 1]) // this one will leave the input pointer past the trailing NUL #define CURSTR() read_lwobj16v0_str(&cc, fn) unsigned char *read_lwobj16v0_str(long *cc1, fileinfo_t *fn) { int cc = *cc1; unsigned char *fp; fp = &CURBYTE(); while (CURBYTE()) NEXTBYTE(); NEXTBYTE(); *cc1 = cc; return fp; } // the function below can be switched to dealing with data coming from a // source other than an in-memory byte pool by adjusting the input data // in "fn" and the above two macros void read_lwobj16v0(fileinfo_t *fn) { unsigned char *fp; long cc; section_t *s; int val; symtab_t *se; // start reading *after* the magic number cc = 8; // init data fn -> sections = NULL; fn -> nsections = 0; while (1) { // NEXTBYTE(); // bail out if no more sections if (!(CURBYTE())) break; fp = CURSTR(); // we now have a section name in fp // create new section entry fn -> sections = lw_realloc(fn -> sections, sizeof(section_t) * (fn -> nsections + 1)); s = &(fn -> sections[fn -> nsections]); fn -> nsections += 1; s -> localsyms = NULL; s -> flags = 0; s -> codesize = 0; s -> name = fp; s -> loadaddress = 0; s -> localsyms = NULL; s -> exportedsyms = NULL; s -> incompletes = NULL; s -> processed = 0; s -> file = fn; // read flags while (CURBYTE()) { switch (CURBYTE()) { case 0x01: s -> flags |= SECTION_BSS; break; default: fprintf(stderr, "%s (%s): unrecognized section flag %02X\n", fn -> filename, s -> name, (int)(CURBYTE())); exit(1); } NEXTBYTE(); } // skip NUL terminating flags NEXTBYTE(); // now parse the local symbol table while (CURBYTE()) { fp = CURSTR(); // fp is the symbol name val = (CURBYTE()) << 8; NEXTBYTE(); val |= (CURBYTE()); NEXTBYTE(); // val is now the symbol value // create symbol table entry se = lw_malloc(sizeof(symtab_t)); se -> next = s -> localsyms; s -> localsyms = se; se -> sym = fp; se -> offset = val; } // skip terminating NUL NEXTBYTE(); // now parse the exported symbol table while (CURBYTE()) { fp = CURSTR(); // fp is the symbol name val = (CURBYTE()) << 8; NEXTBYTE(); val |= (CURBYTE()); NEXTBYTE(); // val is now the symbol value // create symbol table entry se = lw_malloc(sizeof(symtab_t)); se -> next = s -> exportedsyms; s -> exportedsyms = se; se -> sym = fp; se -> offset = val; } // skip terminating NUL NEXTBYTE(); // now parse the incomplete references and make a list of // external references that need resolution while (CURBYTE()) { reloc_t *rp; lw_expr_term_t *term; // we have a reference rp = lw_malloc(sizeof(reloc_t)); rp -> next = s -> incompletes; s -> incompletes = rp; rp -> offset = 0; rp -> expr = lw_expr_stack_create(); // parse the expression while (CURBYTE()) { int tt = CURBYTE(); NEXTBYTE(); switch (tt) { case 0x01: // 16 bit integer tt = CURBYTE() << 8; NEXTBYTE(); tt |= CURBYTE(); NEXTBYTE(); // normalize for negatives... if (tt > 0x7fff) tt -= 0x10000; term = lw_expr_term_create_int(tt); break; case 0x02: // external symbol reference term = lw_expr_term_create_sym(CURSTR(), 0); break; case 0x03: // internal symbol reference term = lw_expr_term_create_sym(CURSTR(), 1); break; case 0x04: // operator term = lw_expr_term_create_oper(CURBYTE()); NEXTBYTE(); break; case 0x05: // section base reference (NULL internal reference is // the section base address term = lw_expr_term_create_sym(NULL, 1); break; default: fprintf(stderr, "%s (%s): bad relocation expression\n", fn -> filename, s -> name); exit(1); } lw_expr_stack_push(rp -> expr, term); lw_expr_term_free(term); } // skip the NUL NEXTBYTE(); // fetch the offset rp -> offset = CURBYTE() << 8; NEXTBYTE(); rp -> offset |= CURBYTE() & 0xff; NEXTBYTE(); } // skip the NUL terminating the relocations NEXTBYTE(); // now set code location and size and verify that the file // contains data going to the end of the code (if !SECTION_BSS) s -> codesize = CURBYTE() << 8; NEXTBYTE(); s -> codesize |= CURBYTE(); NEXTBYTE(); s -> code = &(CURBYTE()); // skip the code if we're not in a BSS section if (!(s -> flags & SECTION_BSS)) { int i; for (i = 0; i < s -> codesize; i++) NEXTBYTE(); } } }