Return to uaelib.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

Annotation of uae/src/uaelib.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * UAE - The U*nix Amiga Emulator
        !             3:  * 
        !             4:  * UAE Library v0.1
        !             5:  * 
        !             6:  * (c) 1996 Tauno Taipaleenmaki <[email protected]>
        !             7:  *
        !             8:  * Change UAE parameters and other stuff from inside the emulation. Creates
        !             9:  * a library called "uae.library" before the boot-up. To check if emulation
        !            10:  * is running we simply try to open the library. 
        !            11:  * 
        !            12:  * NOTE: The VERY FIRST attempt to open the library will actually create
        !            13:  *       it, so you should always try to open it twice.
        !            14:  * 
        !            15:  * Functions:            Offset  Purpose                      Arguments
        !            16:  * ----------
        !            17:  * D0 = GetVersion()      -0x1E Returns UAE version               -
        !            18:  * D0 = GetUaeConfig(A0)  -0x24 Get UAE Configuration       Pointer to memory
        !            19:  *                                                          block with the size
        !            20:  *                                                          of sizeof(UaeCfg)
        !            21:  *!D0 = SetUaeConfig(A0)  -0x2A Sets UAE Configuration      Pointer to struct
        !            22:  *                                                          UAE_CONFIG
        !            23:  *!D0 = HardReset()       -0x30 Resets the Amiga                  - 
        !            24:  *!D0 = Reset()           -0x36  -- "" --                         -
        !            25:  * D0 = EjectDisk(D0)     -0x3C Ejects a disk               D0 = Drive Number
        !            26:  * D0 = InsertDisk(A0,D0) -0x42 Inserts a disk              D0 = drive number,
        !            27:  *                                                          A0 = ptr to name
        !            28:  * D0 = EnableSound()     -0x48 Enables SOUND (if it was          -
        !            29:  *                              compiled in)      
        !            30:  * D0 = DisableSound()    -0x4E Disables SOUND                    -
        !            31:  * D0 = EnableJoystick()  -0x54 Enables FAKE_JOYSTICK             -
        !            32:  * D0 = DisableJoystick() -0x5A Disables FAKE_JOYSTICK            -
        !            33:  * D0 = SetFrameRate(D0)  -0x60 Changes frame rate          D0 = Framerate
        !            34:  *!D0 = ChgCMemSize(D0)   -0x66 Changes ChipMemSize         D0 = New Mem Size
        !            35:  *                              (DOES A HARD RESET!)
        !            36:  *!D0 = ChgSMemSize(D0)   -0x6C Changes SlowMemSize         D0 = New Mem Size
        !            37:  *                              (DOES A HARD RESET!)
        !            38:  *!D0 = ChgFMemSize(D0)   -0x72 Changes FastmemSize         D0 = New Mem Size
        !            39:  *                              (DOES A HARD RESET!)
        !            40:  * D0 = ChangeLanguage(D0)-0x78 Changes kbd lang.           D0 = Language 
        !            41:  * D0 = ExitEmu()         -0x7E Exits the emulator                -
        !            42:  * D0 = GetDisk(D0,A0)    -0x84 Gets the disks name         D0 = Drive
        !            43:  *                                                          A0 = Space for name
        !            44:  * D0 = Debug()           -0x8A Enters internal debugger          -
        !            45:  * ! means not implemented yet 
        !            46:  */
        !            47: 
        !            48: #include "sysconfig.h"
        !            49: #include "sysdeps.h"
        !            50: 
        !            51: #include <assert.h>
        !            52: #include <string.h>
        !            53: 
        !            54: #include "config.h"
        !            55: #include "options.h"
        !            56: #include "memory.h"
        !            57: #include "custom.h"
        !            58: #include "newcpu.h"
        !            59: #include "xwin.h"
        !            60: #include "autoconf.h"
        !            61: #include "disk.h"
        !            62: #include "os.h"
        !            63: 
        !            64: extern int quit_program;
        !            65: 
        !            66: static ULONG LibBase;
        !            67: 
        !            68: static ULONG opencount=0;
        !            69: static ULONG emulibname, functable,resname,resid, datatable;
        !            70: static CPTR GetVersion,HardReset,Reset,EnableSound,DisableSound,
        !            71:             EnableJoystick,DisableJoystick,SetFrameRate,ChangeLanguage,
        !            72:             ChgCMemSize,ChgSMemSize,ChgFMemSize,EjectDisk,InsertDisk,
        !            73:             ExitEmu, GetUaeConfig, SetUaeConfig,Open,Close,Expunge,Null,
        !            74:             GetDisk,FakeInit,segList,DebugFunc;
        !            75: 
        !            76: /*
        !            77:  * Library "open"
        !            78:  */
        !            79: static ULONG emulib_Open(void)
        !            80: {
        !            81:        opencount++;
        !            82:        put_word( LibBase + 32, get_word( LibBase + 32) + 1 );
        !            83:        return LibBase;
        !            84: }
        !            85: 
        !            86: static ULONG emulib_Close(void)
        !            87: {
        !            88:        if (opencount <= 1)
        !            89:         return 0;
        !            90:        else {
        !            91:              opencount--;
        !            92:              put_word( LibBase + 32, get_word( LibBase + 32) - 1 );
        !            93:              return 0;
        !            94:        }
        !            95: }
        !            96: static ULONG emulib_Expunge(void)
        !            97: {
        !            98:        return 0;
        !            99: }
        !           100: 
        !           101: static ULONG emulib_Null(void)
        !           102: {
        !           103:        return 0;
        !           104: }
        !           105: 
        !           106: /*
        !           107:  * Returns UAE Version
        !           108:  */
        !           109: static ULONG emulib_GetVersion(void)
        !           110: {
        !           111:        return version;
        !           112: }
        !           113: 
        !           114: /*
        !           115:  * Resets your amiga
        !           116:  * 
        !           117:  * DOES NOT WORK YET ! It obviously crashes when this routine returns().. ?
        !           118:  */
        !           119: static ULONG emulib_HardReset(void)
        !           120: {
        !           121:        m68k_reset();
        !           122:        return 0;
        !           123: }
        !           124: 
        !           125: static ULONG emulib_Reset(void)
        !           126: {
        !           127:        m68k_reset();
        !           128:        return 0;
        !           129: }
        !           130: 
        !           131: /*
        !           132:  * Enables SOUND
        !           133:  */
        !           134: static ULONG emulib_EnableSound(void)
        !           135: {
        !           136:     if (!sound_available || produce_sound == 2)
        !           137:        return 0;
        !           138: 
        !           139:     produce_sound = 2;
        !           140:     return 1;
        !           141: }
        !           142: 
        !           143: /*
        !           144:  * Disables SOUND
        !           145:  */
        !           146: static ULONG emulib_DisableSound(void)
        !           147: {
        !           148:     produce_sound = 1;
        !           149:     return 1;
        !           150: }
        !           151: 
        !           152: /*
        !           153:  * Enables FAKE JOYSTICK
        !           154:  */
        !           155: static ULONG emulib_EnableJoystick(void)
        !           156: {
        !           157:     fake_joystick = 1;
        !           158:     return 1;
        !           159: }
        !           160: 
        !           161: /*
        !           162:  * Disables FAKE JOYSTICK
        !           163:  */
        !           164: static ULONG emulib_DisableJoystick(void)
        !           165: {
        !           166:        fake_joystick = 0;
        !           167:        return 1;
        !           168: }
        !           169: 
        !           170: /*
        !           171:  * Sets the framerate
        !           172:  */
        !           173: static ULONG emulib_SetFrameRate(void)
        !           174: {
        !           175:     if (regs.d[0] == 0)
        !           176:        return 0;
        !           177:     else if (regs.d[0] > 20)
        !           178:        return 0;
        !           179:     else {
        !           180:        framerate = regs.d[0];
        !           181:        return 1;
        !           182:     }
        !           183: }
        !           184: 
        !           185: /*
        !           186:  * Changes keyboard language settings
        !           187:  */
        !           188: static ULONG emulib_ChangeLanguage(void)
        !           189: {
        !           190:     if (regs.d[0] > 5)
        !           191:        return 0;
        !           192:     else {
        !           193:        switch( regs.d[0] ) {
        !           194:         case 0:
        !           195:            keyboard_lang = KBD_LANG_US;
        !           196:            break;
        !           197:         case 1:
        !           198:            keyboard_lang = KBD_LANG_DE;
        !           199:            break;
        !           200:         case 2:
        !           201:            keyboard_lang = KBD_LANG_SE;
        !           202:            break;
        !           203:         case 3:
        !           204:            keyboard_lang = KBD_LANG_FR;
        !           205:            break;
        !           206:         case 4:
        !           207:            keyboard_lang = KBD_LANG_IT;
        !           208:            break;
        !           209:         default:
        !           210:            break;
        !           211:        }
        !           212:        return 1;
        !           213:     }
        !           214: }
        !           215: 
        !           216: /*
        !           217:  * Changes CHIPMEMORY Size
        !           218:  *  (reboots)
        !           219:  * 
        !           220:  * DOES NOT WORK YET !  - The m68k_reset does not work from here
        !           221:  */
        !           222: static ULONG emulib_ChgCMemSize(void)
        !           223: {
        !           224:     ULONG memsize = regs.d[0];
        !           225:        
        !           226:     if (memsize != 0x80000 && memsize != 0x100000 && 
        !           227:        memsize != 0x200000) {
        !           228:        memsize = 0x200000;
        !           229:        fprintf(stderr, "Unsupported chipmem size!\n");
        !           230:     }
        !           231:     regs.d[0] = 0;
        !           232:     
        !           233:     chipmem_size = memsize;
        !           234:     m68k_reset();
        !           235:     return 1;
        !           236: }
        !           237: 
        !           238: /*
        !           239:  * Changes SLOWMEMORY Size
        !           240:  *  (reboots)
        !           241:  * 
        !           242:  * DOES NOT WORK YET! - the m68k_reset does not work from here
        !           243:  */
        !           244: static ULONG emulib_ChgSMemSize(void)
        !           245: {
        !           246:        ULONG memsize = regs.d[0];
        !           247:        
        !           248:        if (memsize != 0x80000 && memsize != 0x100000 &&
        !           249:           memsize != 0x180000 && memsize != 0x1C0000) {
        !           250:              memsize = 0;
        !           251:              fprintf(stderr, "Unsupported bogomem size!\n");
        !           252:        }
        !           253:        
        !           254:        regs.d[0] = 0;
        !           255:        bogomem_size = memsize;
        !           256:        m68k_reset();
        !           257:        return 1;
        !           258: }
        !           259: 
        !           260: /* 
        !           261:  * Changes FASTMEMORY Size
        !           262:  *  (reboots)
        !           263:  * 
        !           264:  * DOES NOT WORK YET! - the m68k_reset() does not work from here
        !           265:  */
        !           266: static ULONG emulib_ChgFMemSize(void)
        !           267: {
        !           268:        ULONG memsize = regs.d[0];
        !           269:        
        !           270:        if (memsize != 0x100000 && memsize != 0x200000 &&
        !           271:           memsize != 0x400000 && memsize != 0x800000) {
        !           272:              memsize = 0;
        !           273:              fprintf(stderr, "Unsupported fastmem size!\n");
        !           274:        }
        !           275:        regs.d[0] = 0;
        !           276:        fastmem_size = memsize;
        !           277:        m68k_reset();
        !           278:        return 0;
        !           279: }
        !           280: 
        !           281: /*
        !           282:  * Ejects a disk
        !           283:  */
        !           284: static ULONG emulib_EjectDisk(void)
        !           285: {
        !           286:     ULONG drive = regs.d[0];
        !           287:        
        !           288:     if (drive > 3)
        !           289:        return 0;
        !           290:     
        !           291:     disk_eject( drive );
        !           292:     return 1;
        !           293: }
        !           294: 
        !           295: /*
        !           296:  * Inserts a disk
        !           297:  */
        !           298: static ULONG emulib_InsertDisk(void)
        !           299: {
        !           300:     int    quit = 0,i=0,j;
        !           301:     char   real_name[256];
        !           302:     UBYTE  abyte;
        !           303:     ULONG drive = regs.d[0];
        !           304:     CPTR  name = regs.a[0];
        !           305:     FILE   *file;
        !           306:        
        !           307:     if (drive > 3)
        !           308:        return 0;
        !           309: 
        !           310:     if  (!disk_empty( drive )) {
        !           311:        disk_eject( drive );
        !           312:     }
        !           313:        
        !           314:     while( quit == 0 ) {
        !           315:        abyte = get_byte(name + i);
        !           316:        if (abyte == '\0') {
        !           317:            real_name[i++] = '\0';
        !           318:            quit = 1;
        !           319:        } else {
        !           320:            real_name[i++] = abyte;
        !           321:        }
        !           322:     }
        !           323:     j = strlen( real_name );
        !           324:     if (j <= 0 || j > 255)
        !           325:        return 0;
        !           326: 
        !           327:     if (!(file = fopen(real_name, "r")))
        !           328:        return 0;
        !           329: 
        !           330:     fclose(file);
        !           331:     disk_insert(drive, real_name);
        !           332:     return 1;
        !           333: 
        !           334: }
        !           335: 
        !           336: /*
        !           337:  * Exits the emulator
        !           338:  */
        !           339: static ULONG emulib_ExitEmu(void)
        !           340: {
        !           341:        broken_in = 1;
        !           342:        regs.spcflags |= SPCFLAG_BRK;
        !           343:        quit_program = 1;
        !           344:        return 1;
        !           345: }
        !           346: 
        !           347: /*
        !           348:  * Gets UAE Configuration
        !           349:  */
        !           350: static ULONG emulib_GetUaeConfig(void)
        !           351: {
        !           352:        int i,j;
        !           353:        CPTR place = regs.a[0];
        !           354: 
        !           355:        put_long(place     , version);
        !           356:        put_long(place +  4, chipmem_size);
        !           357:        put_long(place +  8, bogomem_size);
        !           358:        put_long(place + 12, fastmem_size);
        !           359:        put_long(place + 16, framerate);
        !           360:        put_long(place + 20, produce_sound);
        !           361:        put_long(place + 24, fake_joystick);
        !           362:        put_long(place + 28, keyboard_lang);
        !           363:        if (disk_empty(0))
        !           364:         put_byte(place + 32, 0);
        !           365:        else
        !           366:         put_byte(place + 32, 1);
        !           367:        if (disk_empty(1))
        !           368:         put_byte(place + 33, 0);
        !           369:        else
        !           370:         put_byte(place + 33, 1);
        !           371:        if (disk_empty(2))
        !           372:         put_byte(place + 34, 0);
        !           373:        else
        !           374:         put_byte(place + 34, 1);
        !           375:        if (disk_empty(3))
        !           376:         put_byte(place + 35, 0);
        !           377:        else
        !           378:         put_byte(place + 35, 1);
        !           379:        
        !           380:        for(i=0;i<256;i++) {
        !           381:              put_byte((place + 36 + i), df0[i]);
        !           382:              put_byte((place + 36 + i + 256), df1[i]);
        !           383:              put_byte((place + 36 + i + 512), df2[i]);
        !           384:              put_byte((place + 36 + i + 768), df3[i]);
        !           385:        }
        !           386:        return 1;
        !           387: }
        !           388: 
        !           389: /*
        !           390:  * Sets UAE Configuration
        !           391:  * 
        !           392:  * NOT IMPLEMENTED YET
        !           393:  */
        !           394: static ULONG emulib_SetUaeConfig(void)
        !           395: {
        !           396:        return 1;
        !           397: }
        !           398: 
        !           399: /*
        !           400:  * Gets the name of the disk in the given drive
        !           401:  */
        !           402: static ULONG emulib_GetDisk(void)
        !           403: {
        !           404:     int i;
        !           405:     if (regs.d[0] > 3) 
        !           406:        return 0;
        !           407: 
        !           408:     switch( regs.d[0] ) {
        !           409:      case 0:
        !           410:        for(i=0;i<256;i++) {
        !           411:            put_byte( regs.a[0] + i, df0[i] );
        !           412:        }
        !           413:        break;
        !           414:      case 1:
        !           415:        for(i=0;i<256;i++) {
        !           416:            put_byte( regs.a[0] + i, df1[i] );
        !           417:        }
        !           418:        break;
        !           419:      case 2:
        !           420:        for(i=0;i<256;i++) {
        !           421:            put_byte( regs.a[0] + i, df2[i] );
        !           422:        }
        !           423:        break;
        !           424:      case 3:
        !           425:        for(i=0;i<256;i++) {
        !           426:            put_byte( regs.a[0] + i, df3[i] );
        !           427:        }
        !           428:        break;
        !           429:      default:
        !           430:        break;
        !           431:     }
        !           432:     return 1;
        !           433: }
        !           434: 
        !           435: /*
        !           436:  * Enter debugging state
        !           437:  */
        !           438: static ULONG emulib_Debug(void)
        !           439: {
        !           440:     broken_in = 1;
        !           441:     regs.spcflags |= SPCFLAG_BRK;
        !           442:     return 1;
        !           443: }
        !           444: 
        !           445: static ULONG emulib_FakeInit(void)
        !           446: {
        !           447:     segList = regs.a[0];
        !           448:     return regs.d[0];
        !           449: }
        !           450: 
        !           451: /*
        !           452:  * Creates the UAE.library in memory
        !           453:  */
        !           454: static ULONG emulib_Init(void)
        !           455: {
        !           456:     ULONG tmp1, quit,i;
        !           457:     UBYTE bitti;
        !           458:     ULONG dosbase;
        !           459: 
        !           460:     if (LibBase != 0)
        !           461:        return 0;
        !           462:        
        !           463:     regs.a[0] = functable;
        !           464:     regs.a[1] = datatable;
        !           465:     regs.a[2] = FakeInit;
        !           466:     regs.d[0] = 1024;
        !           467:     regs.d[1] = 0;
        !           468:     tmp1 = CallLib(regs.a[6], -0x54);
        !           469:     if (tmp1 == 0) {
        !           470:        fprintf(stderr, "Cannot create UAE.library! ");
        !           471:        return 0;
        !           472:     }
        !           473:     regs.a[1] = tmp1;
        !           474:     CallLib(regs.a[6], -0x18c);
        !           475:     LibBase = tmp1;
        !           476: #if 0
        !           477:     regs.a[1] = ds("dos.library");
        !           478:     regs.d[0] = 0;
        !           479:     dosbase = CallLib(regs.a[6], -552);
        !           480:     printf("%08lx\n", dosbase);
        !           481: #endif
        !           482:     regs.d[0] = 1;
        !           483:     return 0;
        !           484: }
        !           485: 
        !           486: 
        !           487: /*
        !           488:  * Installs the UAE LIBRARY
        !           489:  */
        !           490: void emulib_install(void)
        !           491: {
        !           492:     ULONG begin, end, inittable, initroutine;
        !           493:     ULONG jotain, func_place, data_place, init_place;
        !           494:        
        !           495:     resname = ds("uae.library");
        !           496:     resid = ds("UAE library 0.1");
        !           497:        
        !           498:     begin = here();
        !           499:     dw(0x4AFC);
        !           500:     dl(begin);
        !           501:     dl(0);
        !           502:     dw(0x8001);
        !           503:     dw(0x0988);
        !           504:     dl(resname);
        !           505:     dl(resid);
        !           506:     dl(here() + 4);
        !           507: 
        !           508:     dl(1024);
        !           509:     func_place = here();
        !           510:     dl(0);
        !           511:     data_place = here();
        !           512:     dl(0);
        !           513:     init_place = here();
        !           514:     dl(0);
        !           515:  
        !           516: /* Code to set up our library */
        !           517: 
        !           518:     initroutine = here();
        !           519:     calltrap(deftrap(emulib_Init));
        !           520:     dw(RTS);
        !           521:        
        !           522:     /* Function table */
        !           523:     Open = here();
        !           524:     calltrap(deftrap(emulib_Open));
        !           525:     dw(RTS);
        !           526:        
        !           527:     Close = here();
        !           528:     calltrap(deftrap(emulib_Close));
        !           529:     dw(RTS);
        !           530:        
        !           531:     Expunge = here();
        !           532:     calltrap(deftrap(emulib_Expunge));
        !           533:     dw(RTS);
        !           534:        
        !           535:     Null = here();
        !           536:     dw(0x203c); dl(1);
        !           537:     dw(RTS);
        !           538: 
        !           539:     GetVersion = here();
        !           540:     calltrap(deftrap(emulib_GetVersion));
        !           541:     dw(RTS);
        !           542:        
        !           543:     GetUaeConfig = here();
        !           544:     calltrap(deftrap(emulib_GetUaeConfig));
        !           545:     dw(RTS);
        !           546:        
        !           547:     SetUaeConfig = here();
        !           548:     calltrap(deftrap(emulib_SetUaeConfig));
        !           549:     dw(RTS);
        !           550: 
        !           551:     HardReset = here();
        !           552:     calltrap(deftrap(emulib_HardReset));
        !           553:     dw(RTS);
        !           554:        
        !           555:     Reset = here();
        !           556:     calltrap(deftrap(emulib_Reset));
        !           557:     dw(RTS);
        !           558:        
        !           559:     EjectDisk = here();
        !           560:     calltrap(deftrap(emulib_EjectDisk));
        !           561:     dw(RTS);
        !           562:        
        !           563:     InsertDisk = here();
        !           564:     calltrap(deftrap(emulib_InsertDisk));
        !           565:     dw(RTS);
        !           566:        
        !           567:     EnableSound = here();
        !           568:     calltrap(deftrap(emulib_EnableSound));
        !           569:     dw(RTS);
        !           570:        
        !           571:     DisableSound = here();
        !           572:     calltrap(deftrap(emulib_DisableSound));
        !           573:     dw(RTS);
        !           574:        
        !           575:     EnableJoystick = here();
        !           576:     calltrap(deftrap(emulib_EnableJoystick));
        !           577:     dw(RTS);
        !           578: 
        !           579:     DisableJoystick = here();
        !           580:     calltrap(deftrap(emulib_DisableJoystick));
        !           581:     dw(RTS);
        !           582:        
        !           583:     SetFrameRate = here();
        !           584:     calltrap(deftrap(emulib_SetFrameRate));
        !           585:     dw(RTS);
        !           586:        
        !           587:     ChgCMemSize = here();
        !           588:     calltrap(deftrap(emulib_ChgCMemSize));
        !           589:     dw(RTS);
        !           590:        
        !           591:     ChgSMemSize = here();
        !           592:     calltrap(deftrap(emulib_ChgSMemSize));
        !           593:     dw(RTS);
        !           594:        
        !           595:     ChgFMemSize = here();
        !           596:     calltrap(deftrap(emulib_ChgFMemSize));
        !           597:     dw(RTS);
        !           598:        
        !           599:     ChangeLanguage = here();
        !           600:     calltrap(deftrap(emulib_ChangeLanguage));
        !           601:     dw(RTS);
        !           602: 
        !           603:     ExitEmu = here();
        !           604:     calltrap(deftrap(emulib_ExitEmu));
        !           605:     dw(RTS);
        !           606: 
        !           607:     GetDisk = here();
        !           608:     calltrap(deftrap(emulib_GetDisk));
        !           609:     dw(RTS);
        !           610: 
        !           611:     DebugFunc = here();
        !           612:     calltrap(deftrap(emulib_Debug));
        !           613:     dw(RTS);
        !           614:        
        !           615:     FakeInit = here();
        !           616:     calltrap(deftrap(emulib_FakeInit));
        !           617:     dw(RTS);
        !           618:        
        !           619:     functable = here();
        !           620:     dl(Open);
        !           621:     dl(Close);
        !           622:     dl(Expunge);
        !           623:     dl(Null);
        !           624:     dl(GetVersion);
        !           625:     dl(GetUaeConfig);
        !           626:     dl(SetUaeConfig);
        !           627:     dl(HardReset);
        !           628:     dl(Reset);
        !           629:     dl(EjectDisk);
        !           630:     dl(InsertDisk);
        !           631:     dl(EnableSound);
        !           632:     dl(DisableSound);
        !           633:     dl(EnableJoystick);
        !           634:     dl(DisableJoystick);
        !           635:     dl(SetFrameRate);
        !           636:     dl(ChgCMemSize);
        !           637:     dl(ChgSMemSize);
        !           638:     dl(ChgFMemSize);
        !           639:     dl(ChangeLanguage);
        !           640:     dl(ExitEmu);
        !           641:     dl(GetDisk);
        !           642:     dl(DebugFunc);
        !           643:     dl(0xFFFFFFFF);
        !           644: 
        !           645:     datatable = here();
        !           646:     dw(0xE000);
        !           647:     dw(0x0008);
        !           648:     dw(0x0900);
        !           649:     dw(0xC000);
        !           650:     dw(0x000A);
        !           651:     dl(resname);
        !           652:     dw(0xE000);
        !           653:     dw(0x000E);
        !           654:     dw(0x0600);
        !           655:     dw(0xD000);
        !           656:     dw(0x0014);
        !           657:     dw(0x0001);
        !           658:     dw(0xD000);
        !           659:     dw(0x0000);
        !           660:     dw(0x0000);
        !           661:     dw(0xC000);
        !           662:     dw(0x0018);
        !           663:     dl(resid);
        !           664:     dl(0x00000000);
        !           665:     
        !           666:     end = here();
        !           667: 
        !           668:     org(begin + 6);           /* Load END value */
        !           669:     dl(end);
        !           670: 
        !           671:     org(data_place);
        !           672:     dl(datatable);
        !           673:        
        !           674:     org(func_place);
        !           675:     dl(functable);
        !           676: 
        !           677:     org(init_place);
        !           678:     dl(initroutine);
        !           679:        
        !           680:     org(end);
        !           681: }

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