Archipelago » qemu

    pool = [ [ NSAutoreleasePool alloc ] init ];

    distantPast = [ NSDate distantPast ];

    do {

        event = [ NSApp nextEventMatchingMask:NSAnyEventMask untilDate:distantPast

                        inMode: NSDefaultRunLoopMode dequeue:YES ];

                                /* emulate caps lock and num lock keydown and keyup */

                                kbd_put_keycode(keycode);

                                kbd_put_keycode(keycode | 0x80);

                                if (keycode & 0x80)

                                    kbd_put_keycode(0xe0);

                                if (modifiers_state[keycode] == 0) {

                                /* toggle Monitor */

                                case 0x02 ... 0x0a: /* '1' to '9' keys */

                                    console_select(keycode - 0x02);

                                    break;

                                }

                            }

                        } else {

                            /* handle standard key events */

                                if (keycode & 0x80) //check bit for e0 in front

                                    kbd_put_keycode(0xe0);

                                kbd_put_keycode(keycode & 0x7f); //remove e0 bit in front

                case NSKeyUp:

                    {

                        int keycode = cocoa_keycode_to_qemu([event keyCode]);   

                            if (keycode & 0x80)

                                kbd_put_keycode(0xe0);

                            kbd_put_keycode(keycode | 0x80); //add 128 to signal release of key

    TTY_STATE_CSI,

};

struct TextConsole {

    int text_console; /* true if text console */

    DisplayState *ds;

    int g_width, g_height;

    int width;

    int height;

static TextConsole *consoles[MAX_CONSOLES];

static int nb_consoles = 0;

/* convert a RGBA color to a color index usable in graphic primitives */

static unsigned int vga_get_color(DisplayState *ds, unsigned int rgba)

{

                s->g_width = s->ds->width;

                s->g_height = s->ds->height;

                text_console_resize(s);

            console_refresh(s);

        }

    }

}

    }

}

{

    TextConsole *s;

    if (nb_consoles >= MAX_CONSOLES)

        return NULL;

    if (!s) {

        return NULL;

    }

        active_console = s;

    s->ds = ds;

    return s;

}

{

}

CharDriverState *text_console_init(DisplayState *ds)

    chr = qemu_mallocz(sizeof(CharDriverState));

    if (!chr)

        return NULL;

    if (!s) {

        free(chr);

        return NULL;

    }

    chr->opaque = s;

    chr->chr_write = console_puts;

    chr->chr_add_read_handler = console_chr_add_read_handler;

{

}

void DMA_run (void)

{

}

            exit (1);

        }

    }

    /* Load the kernel.  */

    if (!kernel_filename) {

  return (s->cr & PL110_CR_EN) && (s->cr & PL110_CR_PWR);

}

{

    pl110_state *s = (pl110_state *)opaque;

    drawfn* fntable;

    dpy_update(s->ds, 0, first, s->cols, last - first + 1);

}

{

    pl110_state *s = (pl110_state *)opaque;

    s->invalidate = 1;

   pl110_write

};

{

    pl110_state *s;

    int iomemtype;

    s = (pl110_state *)qemu_mallocz(sizeof(pl110_state));

    iomemtype = cpu_register_io_memory(0, pl110_readfn,

                                       pl110_writefn, s);

    s->base = base;

    s->ds = ds;

    s->pic = pic;

    s->irq = irq;

    /* ??? Save/restore.  */

    return s;

}

    slavio_pic_set_irq_cpu(slavio_intctl, irq, level, cpu);

}

static void *iommu;

uint32_t iommu_translate(uint32_t addr)

        slavio_intctl_set_cpu(slavio_intctl, i, envs[i]);

    }

    if (nd_table[0].vlan) {

        if (nd_table[0].model == NULL

            || strcmp(nd_table[0].model, "lance") == 0) {

    uint8_t dac_index, dac_state;

} TCXState;

static void tcx_draw_line32(TCXState *s1, uint8_t *d, 

			    const uint8_t *s, int width)

{

/* Fixed line length 1024 allows us to do nice tricks not possible on

   VGA... */

{

    TCXState *ts = opaque;

    uint32_t page;

    }

}

{

    TCXState *s = opaque;

    int i;

    tcx_dac_writel,

};

{

    TCXState *s;

    int io_memory;

    s = qemu_mallocz(sizeof(TCXState));

    if (!s)

    s->ds = ds;

    s->addr = addr;

    s->vram = vram_base;

    io_memory = cpu_register_io_memory(0, tcx_dac_read, tcx_dac_write, s);

    cpu_register_physical_memory(addr + 0x200000, TCX_DAC_NREGS, io_memory);

    register_savevm("tcx", addr, 1, tcx_save, tcx_load, s);

    qemu_register_reset(tcx_reset, s);

    tcx_reset(s);

    dpy_resize(s->ds, width, height);

}

{

    TCXState *s = opaque;

    FILE *f;

VGAState *vga_state;

int vga_io_memory;

static uint32_t vga_ioport_read(void *opaque, uint32_t addr)

{

    VGAState *s = opaque;

#define GMODE_GRAPH    1

#define GMODE_BLANK 2 

{

    int full_update, graphic_mode;

    if (s->ds->depth == 0) {

}

/* force a full display refresh */

{

    s->last_width = -1;

    s->last_height = -1;

    s->get_bpp = vga_get_bpp;

    s->get_offsets = vga_get_offsets;

    s->get_resolution = vga_get_resolution;

    /* XXX: currently needed for display */

    vga_state = s;

}

/* save the vga display in a PPM image even if no display is

   available */

{

    DisplayState *saved_ds, ds1, *ds = &ds1;

    /* XXX: this is a little hackish */

    saved_ds = s->ds;

    memset(ds, 0, sizeof(DisplayState));

    s->ds = ds;

    s->graphic_mode = -1;

    if (ds->data) {

        ppm_save(filename, ds->data, vga_save_w, vga_save_h, 

static void do_screen_dump(const char *filename)

{

}

static void do_log(const char *items)

        if (!gui_saved_grab)

            sdl_grab_end();

    }

}

static void sdl_refresh(DisplayState *ds)

        sdl_update_caption();

    }

    while (SDL_PollEvent(ev)) {

        switch (ev->type) {

                        break;

                    case 0x02 ... 0x0a: /* '1' to '9' keys */ 

                        console_select(keycode - 0x02);

                            /* display grab if going to a text console */

                            if (gui_grab)

                                sdl_grab_end();

                    default:

                        break;

                    }

                    int keysym;

                    keysym = 0;

                    if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {

                    }

                }

            }

                sdl_process_key(&ev->key);

            break;

        case SDL_QUIT:

#endif

int graphic_depth = 15;

int full_screen = 0;

CharDriverState *serial_hds[MAX_SERIAL_PORTS];

CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];

#ifdef TARGET_I386

static void dumb_refresh(DisplayState *ds)

{

}

void dumb_display_init(DisplayState *ds)

#endif

    }

    monitor_hd = qemu_chr_open(monitor_device);

    if (!monitor_hd) {

        fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);

typedef struct DisplayState DisplayState;

typedef struct TextConsole TextConsole;

CharDriverState *text_console_init(DisplayState *ds);

void console_select(unsigned int index);

int vga_initialize(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 

                   unsigned long vga_ram_offset, int vga_ram_size,

                   unsigned long vga_bios_offset, int vga_bios_size);

/* cirrus_vga.c */

void pci_cirrus_vga_init(PCIBus *bus, DisplayState *ds, uint8_t *vga_ram_base, 

void lance_init(NICInfo *nd, int irq, uint32_t leaddr, uint32_t ledaddr);

/* tcx.c */

	       unsigned long vram_offset, int vram_size, int width, int height);

/* slavio_intctl.c */

void *slavio_intctl_init();

void smc91c111_init(NICInfo *, uint32_t, void *, int);

/* pl110.c */

#endif /* defined(QEMU_TOOL) */