Return to loadfe2.c CVS log

Up to [Tom Morton FrontierVM] / frontvm / hardware

Annotation of frontvm/hardware/loadfe2.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Loads fe2.bin into ST memory and applies all the relocations.
        !             3:  * fe2.bin (and any crap as68k generates) is just plain atari
        !             4:  * prg format, so we could load anything that understood the
        !             5:  * stripped down and weirdified hardware of this VM.
        !             6:  */
        !             7: 
        !             8: #include <SDL.h>
        !             9: #include <SDL_types.h>
        !            10: 
        !            11: #include "main.h"
        !            12: #include "decode.h"
        !            13: #include "dialog.h"
        !            14: #include "file.h"
        !            15: #include "m68000.h"
        !            16: #include "memAlloc.h"
        !            17: #include "stMemory.h"
        !            18: #include "loadfe2.h"
        !            19: 
        !            20: static void *fe2file;
        !            21: static long len;
        !            22: static long code_end;
        !            23: static int buf_pos;
        !            24: 
        !            25: static int rd_int ()
        !            26: {
        !            27:        int val = STMemory_Swap68000Long (*(Uint32 *)(fe2file+buf_pos));
        !            28:        buf_pos += 4;
        !            29:        return val;
        !            30: }
        !            31: 
        !            32: static unsigned char rd_byte ()
        !            33: {
        !            34:        unsigned char val = *(unsigned char*)(fe2file+buf_pos);
        !            35:        buf_pos++;
        !            36:        return val;
        !            37: }
        !            38: 
        !            39: static int get_fixup (int reloc)
        !            40: {
        !            41:        int old_bufpos;
        !            42:        int next;
        !            43:        static int reloc_pos;
        !            44: 
        !            45:        old_bufpos = buf_pos;
        !            46:        if (reloc == 0) {
        !            47:                buf_pos = code_end;
        !            48:                reloc = rd_int ();
        !            49:                reloc_pos = buf_pos;
        !            50:                buf_pos = old_bufpos;
        !            51:                if (reloc == 0) return 0;
        !            52:                else return reloc + FE2BASE;
        !            53:        } else {
        !            54:                buf_pos = reloc_pos;
        !            55: again:
        !            56:                next = rd_byte ();
        !            57:                if (next == 0) {
        !            58:                        buf_pos = old_bufpos;
        !            59:                        return 0;
        !            60:                } else if (next == 1) {
        !            61:                        reloc += 254;
        !            62:                        goto again;
        !            63:                }
        !            64:                else reloc += next;
        !            65:                reloc_pos = buf_pos;
        !            66:                buf_pos = old_bufpos;
        !            67:                return reloc;
        !            68:        }
        !            69: }
        !            70: 
        !            71: void LoadFE2 ()
        !            72: {
        !            73:        int reloc, next, pos, i = 0;
        !            74:        fe2file = File_Read ("fe2.bin", NULL, &len, NULL);
        !            75:        
        !            76:        if (!len) {
        !            77:                printf ("Error loading fe2.bin\n");
        !            78:                SDL_Quit ();
        !            79:                exit (-2);
        !            80:        }
        !            81:        buf_pos = 2;
        !            82:        code_end = 0x1c + rd_int ();
        !            83:        
        !            84:        reloc = FE2BASE;
        !            85:        for (i=0x1c; i<code_end; i++) {
        !            86:                STMemory_WriteByte (reloc, *(char *)(fe2file+i));
        !            87:                reloc++;
        !            88:        }
        !            89: 
        !            90:        i=0;
        !            91:        reloc = get_fixup (0);
        !            92:        while (reloc) {
        !            93:                i++;
        !            94:                pos = buf_pos;
        !            95:                /* address to be modified */
        !            96:                buf_pos = reloc;
        !            97:                next = STMemory_ReadLong (buf_pos);
        !            98:                next += FE2BASE;
        !            99:                STMemory_WriteLong (buf_pos, next);
        !           100:                if (next > code_end+FE2BASE) {
        !           101:                        printf ("Reloc 0x%x (0x%x) out of range..\n", next, reloc+FE2BASE);
        !           102:                }
        !           103:                buf_pos = pos;
        !           104:                reloc = get_fixup (reloc);
        !           105:        }
        !           106:        printf ("fe2.bin 0x%lx bytes (code end 0x%lx), %d fixups; loaded at 0x%x.\n", len, code_end, i, FE2BASE);
        !           107:        
        !           108:        Memory_Free (fe2file);
        !           109: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.