int main(int argc, char **argv) {
(void)argc;
(void)argv;
/* open connection with the server */
nil_.con = xcb_connect(0, 0);
if (xcb_connection_has_error(nil_.con)) {
NIL_ERR("xcb_connect %p", (void *)nil_.con);
exit(1);
}
/* 1st stage */
if ((init_screen() != 0) || (init_key() != 0) || (init_mouse() != 0)) {
xcb_disconnect(nil_.con);
exit(1);
}
/* 2nd stage */
if ((init_cursor() != 0) || (init_color() != 0) != (init_font() != 0)
|| (init_bar() != 0) || (init_wm() != 0)) {
cleanup();
exit(1);
}
xcb_flush(nil_.con);
recv_events();
cleanup();
return 0;
}
static int windows_wminput_init(void)
{
RAWINPUTDEVICELIST *devlist = NULL;
UINT ct = 0;
UINT i;
available_mice = 0;
if (!find_api_symbols()) /* only supported on WinXP and later. */
return -1;
pGetRawInputDeviceList(NULL, &ct, sizeof (RAWINPUTDEVICELIST));
if (ct == 0) /* no devices. */
return 0;
devlist = (PRAWINPUTDEVICELIST) alloca(sizeof (RAWINPUTDEVICELIST) * ct);
pGetRawInputDeviceList(devlist, &ct, sizeof (RAWINPUTDEVICELIST));
for (i = 0; i < ct; i++)
init_mouse(&devlist[i]);
if (!init_event_queue())
{
cleanup_window();
available_mice = 0;
} /* if */
return available_mice;
} /* windows_wminput_init */
/* mick_init:
* Initialises the mickey-mode driver.
*/
static int mick_init(void)
{
if (os_type == OSTYPE_WINNT)
return -1;
mick_lock();
return init_mouse(mick_handler);
}
void FCF_Init (libusbSource * src) {
init_gps(src);
init_theo_imu(src);
init_adis_imu(src);
init_mouse(src); //read from usb mouse; set your hw values in is_mouse()
init_mouse2(src); //read from a 2nd usb mouse; set your hw values in is_mouse2()
//InitProfiling();
//init_virtgyro(src); //read from socket
}
/* int33_init:
* Initialises the int 0x33 driver.
*/
static int int33_init(void)
{
if (os_type == OSTYPE_WINNT)
return -1;
LOCK_VARIABLE(mousedrv_int33);
LOCK_FUNCTION(int33_handler);
return init_mouse(int33_handler);
}
/* win2k_init:
* Initialises the win2k driver.
*/
static int win2k_init(void)
{
/* only for use under Win2k */
if (os_type != OSTYPE_WINNT)
return -1;
mick_lock();
return init_mouse(mick_handler);
}
/* polling_init:
* Initialises the periodic timer driver.
*/
static int polling_init(void)
{
if (os_type == OSTYPE_WINNT)
return -1;
LOCK_VARIABLE(mousedrv_polling);
LOCK_FUNCTION(polling_timer_poll);
return init_mouse(NULL);
}
/* winnt_init:
* Initialises the WinNT driver.
*/
static int winnt_init(void)
{
/* only for use under WinNT */
if (os_type != OSTYPE_WINNT)
return -1;
LOCK_VARIABLE(mousedrv_polling);
LOCK_FUNCTION(polling_timer_poll);
return init_mouse(NULL);
}
void
suspend_mouse(void *h)
{
struct gpm_mouse_spec *gms = h;
if (!gms) return;
gms->h = init_mouse(gms->cons, 1);
if (gms->h < 0) return;
clear_handlers(gms->h);
}
void
resume_mouse(void *h)
{
struct gpm_mouse_spec *gms = h;
if (!gms) return;
gms->h = init_mouse(gms->cons, 0);
if (gms->h < 0) return;
set_handlers(gms->h, (select_handler_T) gpm_mouse_in, NULL, NULL, gms);
}
static int x11_xinput2_init_internal(void)
{
const char *ext = "XInputExtension";
XIDeviceInfo *device_list = NULL;
int device_count = 0;
int available = 0;
int event = 0;
int error = 0;
int major = 2;
int minor = 0;
int i = 0;
xinput2_cleanup(); /* just in case... */
if (getenv("MANYMOUSE_NO_XINPUT2") != NULL)
return -1;
if (!find_api_symbols())
return -1; /* couldn't find all needed symbols. */
display = pXOpenDisplay(NULL);
if (display == NULL)
return -1; /* no X server at all */
Xext_handler = pXSetExtensionErrorHandler(xext_errhandler);
available = (pXQueryExtension(display, ext, &xi2_opcode, &event, &error) &&
(pXIQueryVersion(display, &major, &minor) != BadRequest));
pXSetExtensionErrorHandler(Xext_handler);
Xext_handler = NULL;
if (!available)
return -1; /* no XInput2 support. */
/*
* Register for events first, to prevent a race where we unplug a
* device between when we queried for the list and when we start
* listening for changes.
*/
if (!register_for_events(display))
return -1;
device_list = pXIQueryDevice(display, XIAllDevices, &device_count);
for (i = 0; i < device_count; i++)
{
MouseStruct *mouse = &mice[available_mice];
if (init_mouse(mouse, &device_list[i]))
available_mice++;
} /* for */
pXIFreeDeviceInfo(device_list);
return available_mice;
} /* x11_xinput2_init_internal */
/*
* ttopen - this function is called once to set up the terminal device
* streams. if called as pine composer, don't mess with
* tty modes, but set signal handlers.
*/
int
ttopen(void)
{
if(Pmaster == NULL){
Raw(1);
#ifdef MOUSE
if(gmode & MDMOUSE)
init_mouse();
#endif /* MOUSE */
xonxoff_proc(preserve_start_stop);
}
picosigs();
return(1);
}
void init(void)
{
init_video();
init_mm();
init_trap();
init_irq();
init_8259a();
init_keyboard();
init_timer();
init_harddisk();
init_mouse();
io_sti();
init_resource();
do_test();
}
/*----------------------------------------------------------------------
Initialize the tty driver to do single char I/O and whatever else (UNIX)
Args: struct pine
Result: tty driver is put in raw mode so characters can be read one
at a time. Returns -1 if unsuccessful, 0 if successful.
Some file descriptor voodoo to allow for pipes across vforks. See
open_mailer for details.
----------------------------------------------------------------------*/
int
init_tty_driver(struct pine *ps)
{
#ifdef MOUSE
if(F_ON(F_ENABLE_MOUSE, ps_global))
init_mouse();
#endif /* MOUSE */
/* turn off talk permission by default */
if(F_ON(F_ALLOW_TALK, ps))
allow_talk(ps);
else
disallow_talk(ps);
return(PineRaw(1));
}
t_all *init_all()
{
t_all *str_all;
str_all = xmalloc(sizeof(*str_all));
if ((str_all->mlx_ptr = mlx_init()) == NULL)
return (NULL);
if ((str_all->win_ptr = mlx_new_window(str_all->mlx_ptr, WIN_X,
WIN_Y, WIN_NAME)) == NULL)
{
xfree(str_all);
return (NULL);
}
str_all->mouse = init_mouse();
str_all->fen = NULL;
load_hooks(str_all);
return (str_all);
}
void *
handle_mouse(int cons, void (*fn)(void *, unsigned char *, int),
void *data)
{
int h;
struct gpm_mouse_spec *gms;
h = init_mouse(cons, 0);
if (h < 0) return NULL;
gms = mem_alloc(sizeof(*gms));
if (!gms) return NULL;
gms->h = h;
gms->cons = cons;
gms->fn = fn;
gms->data = data;
set_handlers(h, (select_handler_T) gpm_mouse_in, NULL, NULL, gms);
return gms;
}
static int x11_xinput_init_internal(void)
{
int i;
xinput_cleanup(); /* just in case... */
if (getenv("MANYMOUSE_NO_XINPUT") != NULL)
return(-1);
if (!find_api_symbols())
return(-1); /* couldn't find all needed symbols. */
display = pXOpenDisplay(NULL);
if (display == NULL)
return(-1); /* no X server at all */
/* Stop stderr output in case XInput extension is missing... */
Xext_handler = pXSetExtensionErrorHandler(xext_errhandler);
extver = pXGetExtensionVersion(display, INAME);
pXSetExtensionErrorHandler(Xext_handler);
Xext_handler = NULL;
if ((extver == NULL) || (extver == (XExtensionVersion *) NoSuchExtension))
return(-1); /* no such extension */
if (extver->present == XI_Absent)
return(-1); /* extension not available. */
device_list = pXListInputDevices(display, &device_count);
if (device_list == NULL)
return(-1);
for (i = 0; i < device_count; i++)
{
MouseStruct *mouse = &mice[available_mice];
if (init_mouse(mouse, &device_list[i]))
available_mice++;
} /* for */
return(available_mice);
} /* x11_xinput_init_internal */
void bootmain()
{
init_palette();
clear_screen(15);
//boxfill8( (unsigned char *)0xa0000,320,0, 0,0,30,40);
draw_window();
bootinfo *btinfo=(bootinfo *)0xff0;
init_screen(btinfo);
//while(1);
putchar('a',7,30,40);
/*
if(btinfo->xsize=320)
clear_screen(3 );
*/
puts("1234355656",3,10,70);
puts("hello world",8,10,100);
//显示变量，只是实现了%d的处理，后面的以后再完善
int a=320,b=200;
char str[20];
sprintf(str,"xsize=%d,ysize=%d",a,b);
puts(str,8,10,130);
char mouse[16*16];
init_gdtidt();
init_mouse(mouse,7);
display_mouse((char*)0xa0000,320,16,16,160,100,mouse,16);
fpt cls=clear_screen;
(*cls)(3);
//display_mouse((char*)0xa0000,320,16,16,160,100,mouse,16);
while(1);
}
void
tty_init (gboolean mouse_enable, gboolean is_xterm)
{
initscr ();
#ifdef HAVE_ESCDELAY
/*
* If ncurses exports the ESCDELAY variable, it should be set to
* a low value, or you'll experience a delay in processing escape
* sequences that are recognized by mc (e.g. Esc-Esc). On the other
* hand, making ESCDELAY too small can result in some sequences
* (e.g. cursor arrows) being reported as separate keys under heavy
* processor load, and this can be a problem if mc hasn't learned
* them in the "Learn Keys" dialog. The value is in milliseconds.
*/
ESCDELAY = 200;
#endif /* HAVE_ESCDELAY */
/* use Ctrl-g to generate SIGINT */
cur_term->Nttyb.c_cc[VINTR] = CTRL ('g'); /* ^g */
/* disable SIGQUIT to allow use Ctrl-\ key */
cur_term->Nttyb.c_cc[VQUIT] = NULL_VALUE;
tcsetattr (cur_term->Filedes, TCSANOW, &cur_term->Nttyb);
tty_start_interrupt_key ();
if (!mouse_enable)
use_mouse_p = MOUSE_DISABLED;
tty_init_xterm_support (is_xterm); /* do it before do_enter_ca_mode() call */
init_mouse ();
do_enter_ca_mode ();
tty_raw_mode ();
noecho ();
keypad (stdscr, TRUE);
nodelay (stdscr, FALSE);
tty_setup_sigwinch (sigwinch_handler);
}
/*
* This function is called once to set up the terminal device streams.
*/
int
ttopen(void)
{
int rows, columns;
mswin_getscreensize (&rows, &columns);
term.t_nrow = rows - 1;
term.t_ncol = columns;
/* term.t_scrsiz = (columns * 2) / 3; */
/*
* Do we implement optimized character insertion and deletion?
* o_insert() and o_delete()
*/
/* inschar = delchar = FALSE; */
/* revexist = TRUE; dead code? */
mswin_setresizecallback (mswin_resize);
init_mouse();
return(1);
}
/** main
*
*/
int
main ( int argc, char **argv )
{
snd_seq_event_t ev;
struct input_event iev;
snd_seq_addr_t addr;
fprintf( stderr, "lsmi-mouse" " v" VERSION "\n" );
get_args( argc, argv );
fprintf( stderr, "Initializing mouse interface...\n" );
if ( -1 == ( fd = open( device, O_RDONLY ) ) )
{
fprintf( stderr, "Error opening event interface! (%s)\n", strerror( errno ) );
exit(1);
}
init_mouse();
fprintf( stderr, "Registering MIDI port...\n" );
seq = open_client( CLIENT_NAME );
port = open_output_port( seq );
if ( sub_name )
{
if ( snd_seq_parse_address( seq, &addr, sub_name ) < 0 )
fprintf( stderr, "Couldn't parse address '%s'", sub_name );
else
if ( snd_seq_connect_to( seq, port, addr.client, addr.port ) < 0 )
{
fprintf( stderr, "Error creating subscription for port %i:%i", addr.client, addr.port );
exit( 1 );
}
}
if ( daemonize )
{
printf( "Running as daemon...\n" );
if ( fork() )
exit( 0 );
else
{
fclose( stdout );
fclose( stderr );
}
}
set_traps();
fprintf( stderr, "Waiting for packets...\n" );
for ( ;; )
{
int i;
read( fd, &iev, sizeof( iev ) );
if ( iev.type != EV_KEY )
continue;
switch ( iev.code )
{
case BTN_LEFT: i = 0; break;
case BTN_MIDDLE: i = 1; break;
case BTN_RIGHT: i = 2; break;
break;
default:
continue;
break;
}
snd_seq_ev_clear( &ev );
switch ( ev.type = map[i].ev_type )
{
case SND_SEQ_EVENT_CONTROLLER:
snd_seq_ev_set_controller( &ev, map[i].channel,
map[i].number,
iev.value == DOWN ? 127 : 0 );
break;
case SND_SEQ_EVENT_NOTEON:
snd_seq_ev_set_noteon( &ev, map[i].channel,
map[i].number,
iev.value == DOWN ? 127 : 0 );
break;
default:
fprintf( stderr,
"Internal error: invalid mapping!\n" );
continue;
break;
}
send_event( &ev );
}
}
void
tty_init (gboolean mouse_enable, gboolean is_xterm)
{
SLtt_Ignore_Beep = 1;
SLutf8_enable (-1); /* has to be called first before any of the other functions. */
SLtt_get_terminfo ();
/*
* If the terminal in not in terminfo but begins with a well-known
* string such as "linux" or "xterm" S-Lang will go on, but the
* terminal size and several other variables won't be initialized
* (as of S-Lang 1.4.4). Detect it and abort. Also detect extremely
* small, large and negative screen dimensions.
*/
if ((COLS < 10) || (LINES < 5)
|| (COLS > SLTT_MAX_SCREEN_COLS) || (LINES > SLTT_MAX_SCREEN_ROWS))
{
fprintf (stderr,
_("Screen size %dx%d is not supported.\n"
"Check the TERM environment variable.\n"), COLS, LINES);
exit (EXIT_FAILURE);
}
tcgetattr (fileno (stdin), &boot_mode);
/* 255 = ignore abort char; XCTRL('g') for abort char = ^g */
SLang_init_tty (XCTRL ('g'), 1, 0);
if (mc_global.tty.ugly_line_drawing)
SLtt_Has_Alt_Charset = 0;
/* If SLang uses fileno(stderr) for terminal input MC will hang
if we call SLang_getkey between calls to open_error_pipe and
close_error_pipe, e.g. when we do a growing view of an gzipped
file. */
if (SLang_TT_Read_FD == fileno (stderr))
SLang_TT_Read_FD = fileno (stdin);
if (tcgetattr (SLang_TT_Read_FD, &new_mode) == 0)
{
#ifdef VDSUSP
new_mode.c_cc[VDSUSP] = NULL_VALUE; /* to ignore ^Y */
#endif
#ifdef VLNEXT
new_mode.c_cc[VLNEXT] = NULL_VALUE; /* to ignore ^V */
#endif
tcsetattr (SLang_TT_Read_FD, TCSADRAIN, &new_mode);
}
tty_reset_prog_mode ();
load_terminfo_keys ();
SLtt_Blink_Mode = tty_use_256colors ()? 1 : 0;
tty_start_interrupt_key ();
/* It's the small part from the previous init_key() */
init_key_input_fd ();
/* For 8-bit locales, NCurses handles 154 (0x9A) symbol properly, while S-Lang
* requires SLsmg_Display_Eight_Bit >= 154 (OR manual filtering if xterm display
* detected - but checking TERM would fail under screen, OR running xterm
* with allowC1Printable).
*/
tty_display_8bit (FALSE);
SLsmg_init_smg ();
if (!mouse_enable)
use_mouse_p = MOUSE_DISABLED;
tty_init_xterm_support (is_xterm); /* do it before do_enter_ca_mode() call */
init_mouse ();
do_enter_ca_mode ();
tty_keypad (TRUE);
tty_nodelay (FALSE);
tty_setup_sigwinch (sigwinch_handler);
}
void showlogo()
{
struct bitfileheader
{
int bfType;
long bfSize;
int bfReserved1;
int bfReserved2;
long bfOffBits;
long biSize;
long biWidth;
long biHeight;
int biPlanes;
int biBitCount;
long biCompression;
long biSizeImage;
long biXPelsPerMeter;
long biYPelsPerMeter;
long biClrUsed;
long byClrImportant;
};
int xmax = getmaxx();
int ymax = getmaxy();
bitfileheader testing;
palettetype pal;
getpalette(&pal);
int i, j;
char blue, green, red, pix1, pix2, pixel, alpha;
mouse_data mouse;
cleardevice();
if(!init_mouse())
{
closegraph();
cout << "Mouse couldn't be initialised";
}
hide_mouse();
fstream bitmap("logo.saq", ios::in);
bitmap.read((char*)&testing, sizeof testing);
for (i = 0; i< pal.size; i++)
{
bitmap.read(&blue,1);
bitmap.read(&green,1);
bitmap.read(&red,1);
bitmap.read(&alpha,1);
// setrgbpalette(pal.colors[i],(int)red,(int)green,(int)blue);
}
for (i = 1; i<= testing.biHeight; i++)
for (j = 1; j <= testing.biWidth; j+=2)
{
bitmap.read(&pixel, 1);
pix1 = pixel & 0xF0;
pix1 >>= 4;
pix2 = pixel & 0x0F;
putpixel(j, testing.biHeight - i,pix1);
putpixel(j+1, testing.biHeight - i,pix2);
}
show_mouse();
do
{
read_mouse(&mouse);
}while(!kbhit() || !button_press(LEFT_BUTTON, &mouse));
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
multiboot_info_t *mbi;
uint8_t* filesystem_address;
/* Clear the screen. */
clear();
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
while(mod_count < mbi->mods_count) {
filesystem_address = (uint8_t*)mod->mod_start;
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
mod++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000;
ltr(KERNEL_TSS);
}
int z = 0;
reset_scr();
//set the IDT
set_idt();
lidt(idt_desc_ptr);
/* Init the PIC */
i8259_init();
/* Initialize devices, memory, filesystem, enable device interrupts on the
* PIC, any other initialization stuff... */
//init paging
init_paging();
//init filesystem
init_filesys(filesystem_address);
//init keyboard
init_keyboard();
//init the rtc
init_rtc();
//init the mouse
init_mouse();
//clear the screen
reset_scr();
// boot_screen();
for(z = 0; z < 3; z++)
{
terminal_init();
}
node* buffer = screens[0];
reset_buf(buffer);
//display the status bar
/* Enable interrupts */
sti();
/* Do not enable the following until after you have set up your
* IDT correctly otherwise QEMU will triple fault and simple close
* without showing you any output */
boot_screen();
//sample mario sound
for(z = 0; z < 500000; z++)
play_sound(1000);
for(z = 0; z < 500000; z++)
play_sound(100);
for(z = 0; z < 500000; z++)
play_sound(900);
for(z = 0; z < 50000; z++)
play_sound(200);
for(z = 0; z < 500000; z++)
play_sound(800);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(700);
for(z = 0; z < 500000; z++)
play_sound(400);
for(z = 0; z < 500000; z++)
play_sound(600);
for(z = 0; z < 500000; z++)
play_sound(500);
for(z = 0; z < 500000; z++)
play_sound(500);
for(z = 0; z < 500000; z++)
play_sound(1000);
for(z = 0; z < 500000; z++)
play_sound(400);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(300);
for(z = 0; z < 500000; z++)
play_sound(200);
//boot_screen();
nosound();
reset_scr();
//init PIT for sound, timer
init_pit(0, 100);
/////////////////////////////////////////////////////////////
// void imperial();
status_bar();
/* Execute the first program (`shell') ... */
uint8_t fname[33] = "shell";
execute(fname);
/* We should never get to this point */
//printf("Initial shell halted.");
/* Spin (nicely, so we don't chew up cycles) */
asm volatile(".1: hlt; jmp .1;");
}
/* Main program. Parses command line options, reads the configuration
* file, initializes the mouse and associated files and launches the main
* event loop. */
int
main(int argc, char **argv)
{
char *conffile, *modelist, *tstat;
int needconf, nodaemon, opt;
struct block *conf;
setprogname(argv[0]);
(void)memset(&Mouse, 0, sizeof(struct mouse));
conffile = _PATH_CONF;
modelist = NULL;
needconf = 0;
nodaemon = -1;
/* Parse command line options */
while ((opt = getopt(argc, argv, "Dd:f:m:n")) != -1) {
switch (opt) {
case 'D':
debug++;
break;
case 'd': /* Mouse device name */
Mouse.m_devname = optarg;
break;
case 'f': /* Configuration file name */
needconf = 1;
conffile = optarg;
break;
case 'm': /* List of modes to activate */
modelist = optarg;
break;
case 'n': /* No daemon */
nodaemon = 1;
break;
default:
usage();
/* NOTREACHED */
}
}
/* Read the configuration file and get some basic properties */
config_read(conffile, needconf);
conf = config_get_mode("Global");
if (nodaemon == -1)
nodaemon = block_get_propval_int(conf, "nodaemon", 0);
X_Console = block_get_propval_int(conf, "xconsole", -1);
X_Console_Delay = block_get_propval_int(conf, "xconsole_delay",
X_Console_Delay);
/* Open wsdisplay status device */
tstat = block_get_propval(conf, "ttystat", _PATH_TTYSTAT);
Mouse.m_statfd = open(tstat, O_RDONLY | O_NONBLOCK, 0);
if (Mouse.m_statfd == -1)
log_err(EXIT_FAILURE, "cannot open %s", tstat);
/* Initialize mouse information and attach modes */
if (Mouse.m_devname == NULL)
Mouse.m_devname = block_get_propval(conf, "device",
_PATH_DEFAULT_MOUSE);
Mouse.m_fifoname = block_get_propval(conf, "fifo", NULL);
init_mouse();
if (modelist != NULL)
attach_modes(modelist);
else
attach_modes(block_get_propval(conf, "modes", "selection"));
/* Setup signal handlers */
(void)signal(SIGINT, signal_terminate);
(void)signal(SIGKILL, signal_terminate);
(void)signal(SIGQUIT, signal_terminate);
(void)signal(SIGTERM, signal_terminate);
if (!nodaemon) {
/* Become a daemon */
if (daemon(0, 0) == -1)
log_err(EXIT_FAILURE, "failed to become a daemon");
/* Create the pidfile, if wanted */
Pid_File = block_get_propval(conf, "pidfile", NULL);
if (pidfile(Pid_File) == -1)
log_warn("pidfile %s", Pid_File);
Foreground = 0;
}
event_loop();
/* NOTREACHED */
return EXIT_SUCCESS;
}
void init_char_devices()
{
init_key_board();
init_mouse();
init_console();
}
int main()
{
//shell vars
bool render = false;
//allegro vars
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
//allegro init functions
printf ("Initializing allegro\n");
if (!al_init())
{
al_show_native_message_box(NULL, NULL, NULL, "failed", NULL, 0);
return -1;
}
printf("Creating display\n");
display = al_create_display(WIDTH, HEIGHT);
if (!display)
{
al_show_native_message_box(NULL, NULL, NULL, "failed", NULL, 0);
return -1;
}
printf("Installing addons\n");
al_init_font_addon();
al_init_ttf_addon();
al_init_primitives_addon();
al_init_image_addon();
al_install_keyboard();
al_install_mouse();
al_install_audio();
al_init_acodec_addon();
al_reserve_samples(10);
//project inits
srand(time(NULL));
printf("Initializing timer\n");
event_queue = al_create_event_queue();
timer = al_create_timer(1.0 / FPS);
printf("Registering event sources\n");
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_start_timer(timer);
printf("Init mouse and keyboard\n");
init_keyboard();
init_mouse();
printf("Loading assets\n");
load_bitmaps();
load_fonts();
load_samples();
printf ("Creating manager\n");
push_state(new TitleMenu());
printf("Beginning game\n");
while (!is_game_over())
{
//declare an event
ALLEGRO_EVENT event;
//monitor event sources
al_wait_for_event(event_queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
end_game();
}
else if (event.type == ALLEGRO_EVENT_TIMER)
{
render = true;
update_mouse();
update_keyboard();
handle_key();
update_game();
}
// Render screen
if (render && al_event_queue_is_empty(event_queue))
{
render = false;
render_game();
al_flip_display();
}
}
unload_assets();
al_destroy_event_queue(event_queue);
al_destroy_display(display);
al_destroy_timer(timer);
return 0;
}
void CIOLIBCALL ciolib_mouse_thread(void *data)
{
int timedout;
int timeout_button=0;
int but;
int delay;
clock_t ttime=0;
SetThreadName("Mouse");
init_mouse();
while(1) {
timedout=0;
if(timeout_button) {
delay=state.timeout[timeout_button-1]-MSEC_CLOCK();
if(delay<=0) {
timedout=1;
}
else {
timedout=!listSemTryWaitBlock(&state.input,delay);
}
}
else {
listSemWait(&state.input);
}
if(timedout) {
state.timeout[timeout_button-1]=0;
switch(state.button_state[timeout_button-1]) {
case MOUSE_SINGLEPRESSED:
/* Press event */
add_outevent(CIOLIB_BUTTON_PRESS(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_CLICKED:
/* Click Event */
add_outevent(CIOLIB_BUTTON_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_DOUBLEPRESSED:
/* Click event, then press event */
add_outevent(CIOLIB_BUTTON_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
add_outevent(CIOLIB_BUTTON_PRESS(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_DOUBLECLICKED:
/* Double-click event */
add_outevent(CIOLIB_BUTTON_DBL_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_TRIPLEPRESSED:
/* Double-click event, then press event */
add_outevent(CIOLIB_BUTTON_DBL_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
add_outevent(CIOLIB_BUTTON_PRESS(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_TRIPLECLICKED:
/* Triple-click event */
add_outevent(CIOLIB_BUTTON_TRPL_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_QUADPRESSED:
/* Triple-click evetn then press event */
add_outevent(CIOLIB_BUTTON_TRPL_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
add_outevent(CIOLIB_BUTTON_PRESS(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
break;
case MOUSE_QUADCLICKED:
add_outevent(CIOLIB_BUTTON_QUAD_CLICK(timeout_button),state.button_x[timeout_button-1],state.button_y[timeout_button-1]);
/* Quad click event (This doesn't need a timeout does it? */
break;
}
state.button_state[timeout_button-1]=MOUSE_NOSTATE;
}
else {
struct in_mouse_event *in;
in=listShiftNode(&state.input);
if(in==NULL) {
YIELD();
continue;
}
but=CIOLIB_BUTTON_NUMBER(in->event);
switch(CIOLIB_BUTTON_BASE(in->event)) {
case CIOLIB_MOUSE_MOVE:
if(in->x==state.curx
&& in->y==state.cury)
break;
add_outevent(CIOLIB_MOUSE_MOVE,in->x,in->y);
for(but=1;but<=3;but++) {
switch(state.button_state[but-1]) {
case MOUSE_NOSTATE:
if(state.buttonstate & CIOLIB_BUTTON(but)) {
add_outevent(CIOLIB_BUTTON_DRAG_START(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
state.button_state[but-1]=MOUSE_DRAGSTARTED;
}
break;
case MOUSE_SINGLEPRESSED:
add_outevent(CIOLIB_BUTTON_DRAG_START(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
state.button_state[but-1]=MOUSE_DRAGSTARTED;
break;
case MOUSE_CLICKED:
add_outevent(CIOLIB_BUTTON_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
state.button_state[but-1]=MOUSE_NOSTATE;
break;
case MOUSE_DOUBLEPRESSED:
add_outevent(CIOLIB_BUTTON_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_START(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
state.button_state[but-1]=MOUSE_DRAGSTARTED;
break;
case MOUSE_DOUBLECLICKED:
add_outevent(CIOLIB_BUTTON_DBL_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
state.button_state[but-1]=MOUSE_NOSTATE;
break;
case MOUSE_TRIPLEPRESSED:
add_outevent(CIOLIB_BUTTON_DBL_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_START(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
state.button_state[but-1]=MOUSE_DRAGSTARTED;
break;
case MOUSE_TRIPLECLICKED:
add_outevent(CIOLIB_BUTTON_TRPL_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
state.button_state[but-1]=MOUSE_NOSTATE;
break;
case MOUSE_QUADPRESSED:
add_outevent(CIOLIB_BUTTON_TRPL_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_START(but),state.button_x[but-1],state.button_y[but-1]);
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
state.button_state[but-1]=MOUSE_DRAGSTARTED;
break;
case MOUSE_DRAGSTARTED:
add_outevent(CIOLIB_BUTTON_DRAG_MOVE(but),in->x,in->y);
break;
}
}
break;
case CIOLIB_BUTTON_1_PRESS:
state.buttonstate|=1<<(but-1);
state.knownbuttonstatemask|=1<<(but-1);
switch(state.button_state[but-1]) {
case MOUSE_NOSTATE:
state.button_state[but-1]=MOUSE_SINGLEPRESSED;
state.button_x[but-1]=in->x;
state.button_y[but-1]=in->y;
state.timeout[but-1]=MSEC_CLOCK()+state.click_timeout;
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
if(state.click_timeout==0)
state.timeout[but-1]=0;
if(!more_multies(but,0)) {
add_outevent(CIOLIB_BUTTON_PRESS(but),state.button_x[but-1],state.button_y[but-1]);
state.button_state[but-1]=MOUSE_NOSTATE;
state.timeout[but-1]=0;
}
break;
case MOUSE_CLICKED:
state.button_state[but-1]=MOUSE_DOUBLEPRESSED;
state.timeout[but-1]=MSEC_CLOCK()+state.click_timeout;
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
if(state.click_timeout==0)
state.timeout[but-1]=0;
break;
case MOUSE_DOUBLECLICKED:
state.button_state[but-1]=MOUSE_TRIPLEPRESSED;
state.timeout[but-1]=MSEC_CLOCK()+state.click_timeout;
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
if(state.click_timeout==0)
state.timeout[but-1]=0;
break;
case MOUSE_TRIPLECLICKED:
state.button_state[but-1]=MOUSE_QUADPRESSED;
state.timeout[but-1]=MSEC_CLOCK()+state.click_timeout;
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
if(state.click_timeout==0)
state.timeout[but-1]=0;
break;
}
break;
case CIOLIB_BUTTON_1_RELEASE:
state.buttonstate&= ~(1<<(but-1));
state.knownbuttonstatemask|=1<<(but-1);
switch(state.button_state[but-1]) {
case MOUSE_NOSTATE:
state.button_x[but-1]=in->x;
state.button_y[but-1]=in->y;
add_outevent(CIOLIB_BUTTON_RELEASE(but),state.button_x[but-1],state.button_y[but-1]);
break;
case MOUSE_SINGLEPRESSED:
state.button_state[but-1]=MOUSE_CLICKED;
state.timeout[but-1]=more_multies(but,1)?MSEC_CLOCK()+state.multi_timeout:MSEC_CLOCK();
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
break;
case MOUSE_DOUBLEPRESSED:
state.button_state[but-1]=MOUSE_DOUBLECLICKED;
state.timeout[but-1]=more_multies(but,2)?MSEC_CLOCK()+state.multi_timeout:MSEC_CLOCK();
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
break;
case MOUSE_TRIPLEPRESSED:
state.button_state[but-1]=MOUSE_TRIPLECLICKED;
state.timeout[but-1]=more_multies(but,3)?MSEC_CLOCK()+state.multi_timeout:MSEC_CLOCK();
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
break;
case MOUSE_QUADPRESSED:
state.button_state[but-1]=MOUSE_NOSTATE;
add_outevent(CIOLIB_BUTTON_QUAD_CLICK(but),state.button_x[but-1],state.button_y[but-1]);
state.timeout[but-1]=0;
if(state.timeout[but-1]==0)
state.timeout[but-1]=1;
break;
case MOUSE_DRAGSTARTED:
add_outevent(CIOLIB_BUTTON_DRAG_END(but),in->x,in->y);
state.button_state[but-1]=0;
}
}
state.curx=in->x;
state.cury=in->y;
free(in);
}
timeout_button=0;
for(but=1;but<=3;but++) {
if(state.button_state[but-1]!=MOUSE_NOSTATE
&& state.button_state[but-1]!=MOUSE_DRAGSTARTED
&& state.timeout[but-1]!=0
&& (timeout_button==0 || state.timeout[but-1]<ttime)) {
ttime=state.timeout[but-1];
timeout_button=but;
}
}
}
}
int
main (int argc, char *argv[])
{
GError *mcerror = NULL;
gboolean config_migrated = FALSE;
char *config_migrate_msg;
int exit_code = EXIT_FAILURE;
mc_global.timer = mc_timer_new ();
/* We had LC_CTYPE before, LC_ALL includs LC_TYPE as well */
#ifdef HAVE_SETLOCALE
(void) setlocale (LC_ALL, "");
#endif
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
/* do this before args parsing */
str_init_strings (NULL);
if (!mc_args_parse (&argc, &argv, "mc", &mcerror))
{
startup_exit_falure:
fprintf (stderr, _("Failed to run:\n%s\n"), mcerror->message);
g_error_free (mcerror);
g_free (mc_global.tty.shell);
startup_exit_ok:
str_uninit_strings ();
mc_timer_destroy (mc_global.timer);
return exit_code;
}
/* do this before mc_args_show_info () to view paths in the --datadir-info output */
OS_Setup ();
if (!g_path_is_absolute (mc_config_get_home_dir ()))
{
mc_propagate_error (&mcerror, 0, "%s: %s", _("Home directory path is not absolute"),
mc_config_get_home_dir ());
mc_event_deinit (NULL);
goto startup_exit_falure;
}
if (!mc_args_show_info ())
{
exit_code = EXIT_SUCCESS;
goto startup_exit_ok;
}
if (!events_init (&mcerror))
goto startup_exit_falure;
mc_config_init_config_paths (&mcerror);
config_migrated = mc_config_migrate_from_old_place (&mcerror, &config_migrate_msg);
if (mcerror != NULL)
{
mc_event_deinit (NULL);
goto startup_exit_falure;
}
vfs_init ();
vfs_plugins_init ();
load_setup ();
/* Must be done after load_setup because depends on mc_global.vfs.cd_symlinks */
vfs_setup_work_dir ();
/* Resolve the other_dir panel option. Must be done after vfs_setup_work_dir */
{
char *buffer;
vfs_path_t *vpath;
buffer = mc_config_get_string (mc_panels_config, "Dirs", "other_dir", ".");
vpath = vfs_path_from_str (buffer);
if (vfs_file_is_local (vpath))
saved_other_dir = buffer;
else
g_free (buffer);
vfs_path_free (vpath);
}
/* Set up temporary directory after VFS initialization */
mc_tmpdir ();
/* do this after vfs initialization and vfs working directory setup
due to mc_setctl() and mcedit_arg_vpath_new() calls in mc_setup_by_args() */
if (!mc_setup_by_args (argc, argv, &mcerror))
{
vfs_shut ();
done_setup ();
g_free (saved_other_dir);
mc_event_deinit (NULL);
goto startup_exit_falure;
}
/* check terminal type
* $TEMR must be set and not empty
* mc_global.tty.xterm_flag is used in init_key() and tty_init()
* Do this after mc_args_handle() where mc_args__force_xterm is set up.
*/
mc_global.tty.xterm_flag = tty_check_term (mc_args__force_xterm);
/* NOTE: This has to be called before tty_init or whatever routine
calls any define_sequence */
init_key ();
/* Must be done before installing the SIGCHLD handler [[FIXME]] */
handle_console (CONSOLE_INIT);
#ifdef ENABLE_SUBSHELL
/* Don't use subshell when invoked as viewer or editor */
if (mc_global.mc_run_mode != MC_RUN_FULL)
mc_global.tty.use_subshell = FALSE;
if (mc_global.tty.use_subshell)
subshell_get_console_attributes ();
#endif /* ENABLE_SUBSHELL */
/* Install the SIGCHLD handler; must be done before init_subshell() */
init_sigchld ();
/* We need this, since ncurses endwin () doesn't restore the signals */
save_stop_handler ();
/* Must be done before init_subshell, to set up the terminal size: */
/* FIXME: Should be removed and LINES and COLS computed on subshell */
tty_init (!mc_args__nomouse, mc_global.tty.xterm_flag);
/* start check mc_global.display_codepage and mc_global.source_codepage */
check_codeset ();
/* Removing this from the X code let's us type C-c */
load_key_defs ();
load_keymap_defs (!mc_args__nokeymap);
macros_list = g_array_new (TRUE, FALSE, sizeof (macros_t));
tty_init_colors (mc_global.tty.disable_colors, mc_args__force_colors);
mc_skin_init (NULL, &mcerror);
dlg_set_default_colors ();
input_set_default_colors ();
if (mc_global.mc_run_mode == MC_RUN_FULL)
command_set_default_colors ();
mc_error_message (&mcerror);
#ifdef ENABLE_SUBSHELL
/* Done here to ensure that the subshell doesn't */
/* inherit the file descriptors opened below, etc */
if (mc_global.tty.use_subshell)
init_subshell ();
#endif /* ENABLE_SUBSHELL */
/* Also done after init_subshell, to save any shell init file messages */
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_SAVE);
if (mc_global.tty.alternate_plus_minus)
application_keypad_mode ();
/* Done after subshell initialization to allow select and paste text by mouse
w/o Shift button in subshell in the native console */
init_mouse ();
/* Done after do_enter_ca_mode (tty_init) because in VTE bracketed mode is
separate for the normal and alternate screens */
enable_bracketed_paste ();
/* subshell_prompt is NULL here */
mc_prompt = (geteuid () == 0) ? "# " : "$ ";
if (config_migrated)
{
message (D_ERROR, _("Warning"), "%s", config_migrate_msg);
g_free (config_migrate_msg);
}
/* Program main loop */
if (mc_global.midnight_shutdown)
exit_code = EXIT_SUCCESS;
else
exit_code = do_nc ()? EXIT_SUCCESS : EXIT_FAILURE;
/* Save the tree store */
(void) tree_store_save ();
free_keymap_defs ();
/* Virtual File System shutdown */
vfs_shut ();
flush_extension_file (); /* does only free memory */
mc_skin_deinit ();
tty_colors_done ();
tty_shutdown ();
done_setup ();
if (mc_global.tty.console_flag != '\0' && (quit & SUBSHELL_EXIT) == 0)
handle_console (CONSOLE_RESTORE);
if (mc_global.tty.alternate_plus_minus)
numeric_keypad_mode ();
(void) signal (SIGCHLD, SIG_DFL); /* Disable the SIGCHLD handler */
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_DONE);
if (mc_global.mc_run_mode == MC_RUN_FULL && mc_args__last_wd_file != NULL
&& last_wd_string != NULL && !print_last_revert)
{
int last_wd_fd;
last_wd_fd = open (mc_args__last_wd_file, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
S_IRUSR | S_IWUSR);
if (last_wd_fd != -1)
{
ssize_t ret1;
int ret2;
ret1 = write (last_wd_fd, last_wd_string, strlen (last_wd_string));
ret2 = close (last_wd_fd);
(void) ret1;
(void) ret2;
}
}
g_free (last_wd_string);
g_free (mc_global.tty.shell);
done_key ();
if (macros_list != NULL)
{
guint i;
for (i = 0; i < macros_list->len; i++)
{
macros_t *macros;
macros = &g_array_index (macros_list, struct macros_t, i);
if (macros != NULL && macros->macro != NULL)
(void) g_array_free (macros->macro, FALSE);
}
(void) g_array_free (macros_list, TRUE);
}
/* Check if MAGIC is valid and print the Multiboot information structure
pointed by ADDR. */
void
entry (unsigned long magic, unsigned long addr)
{
uint32_t file_system_start;
multiboot_info_t *mbi;
/* Clear the screen. */
clear();
/* Am I booted by a Multiboot-compliant boot loader? */
if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
printf ("Invalid magic number: 0x%#x\n", (unsigned) magic);
return;
}
/* Set MBI to the address of the Multiboot information structure. */
mbi = (multiboot_info_t *) addr;
/* Print out the flags. */
printf ("flags = 0x%#x\n", (unsigned) mbi->flags);
/* Are mem_* valid? */
if (CHECK_FLAG (mbi->flags, 0))
printf ("mem_lower = %uKB, mem_upper = %uKB\n",
(unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
/* Is boot_device valid? */
if (CHECK_FLAG (mbi->flags, 1))
printf ("boot_device = 0x%#x\n", (unsigned) mbi->boot_device);
/* Is the command line passed? */
if (CHECK_FLAG (mbi->flags, 2))
printf ("cmdline = %s\n", (char *) mbi->cmdline);
if (CHECK_FLAG (mbi->flags, 3)) {
int mod_count = 0;
int i;
module_t* mod = (module_t*)mbi->mods_addr;
file_system_start = mod->mod_start; // store mod_start as start address of file system
while(mod_count < mbi->mods_count) {
printf("Module %d loaded at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_start);
printf("Module %d ends at address: 0x%#x\n", mod_count, (unsigned int)mod->mod_end);
printf("First few bytes of module:\n");
for(i = 0; i<16; i++) {
printf("0x%x ", *((char*)(mod->mod_start+i)));
}
printf("\n");
mod_count++;
mod++;
}
}
/* Bits 4 and 5 are mutually exclusive! */
if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
{
printf ("Both bits 4 and 5 are set.\n");
return;
}
/* Is the section header table of ELF valid? */
if (CHECK_FLAG (mbi->flags, 5))
{
elf_section_header_table_t *elf_sec = &(mbi->elf_sec);
printf ("elf_sec: num = %u, size = 0x%#x,"
" addr = 0x%#x, shndx = 0x%#x\n",
(unsigned) elf_sec->num, (unsigned) elf_sec->size,
(unsigned) elf_sec->addr, (unsigned) elf_sec->shndx);
}
/* Are mmap_* valid? */
if (CHECK_FLAG (mbi->flags, 6))
{
memory_map_t *mmap;
printf ("mmap_addr = 0x%#x, mmap_length = 0x%x\n",
(unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
for (mmap = (memory_map_t *) mbi->mmap_addr;
(unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
mmap = (memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
printf (" size = 0x%x, base_addr = 0x%#x%#x\n"
" type = 0x%x, length = 0x%#x%#x\n",
(unsigned) mmap->size,
(unsigned) mmap->base_addr_high,
(unsigned) mmap->base_addr_low,
(unsigned) mmap->type,
(unsigned) mmap->length_high,
(unsigned) mmap->length_low);
}
/* Construct an LDT entry in the GDT */
{
seg_desc_t the_ldt_desc;
the_ldt_desc.granularity = 0;
the_ldt_desc.opsize = 1;
the_ldt_desc.reserved = 0;
the_ldt_desc.avail = 0;
the_ldt_desc.present = 1;
the_ldt_desc.dpl = 0x0;
the_ldt_desc.sys = 0;
the_ldt_desc.type = 0x2;
SET_LDT_PARAMS(the_ldt_desc, &ldt, ldt_size);
ldt_desc_ptr = the_ldt_desc;
lldt(KERNEL_LDT);
}
/* Construct a TSS entry in the GDT */
{
seg_desc_t the_tss_desc;
the_tss_desc.granularity = 0;
the_tss_desc.opsize = 0;
the_tss_desc.reserved = 0;
the_tss_desc.avail = 0;
the_tss_desc.seg_lim_19_16 = TSS_SIZE & 0x000F0000;
the_tss_desc.present = 1;
the_tss_desc.dpl = 0x0;
the_tss_desc.sys = 0;
the_tss_desc.type = 0x9;
the_tss_desc.seg_lim_15_00 = TSS_SIZE & 0x0000FFFF;
SET_TSS_PARAMS(the_tss_desc, &tss, tss_size);
tss_desc_ptr = the_tss_desc;
tss.ldt_segment_selector = KERNEL_LDT;
tss.ss0 = KERNEL_DS;
tss.esp0 = 0x800000 - 4;
ltr(KERNEL_TSS);
}
///////////////////////////////
/* Initialize first 20 IDT entries for exceptions */
/* Initialize interrupt descriptor entries defined in x86_desc.h*/
int i;
for (i=0; i<EXCEPTION_NUM; i++)
{
idt[i].seg_selector = KERNEL_CS; // set up elements in the exception entry
idt[i].reserved4 = 0;
idt[i].reserved3 = 0;
idt[i].reserved2 = 1;
idt[i].reserved1 = 1;
idt[i].size = 1;
idt[i].reserved0 = 0;
idt[i].dpl = 0;
idt[i].present = 1;
SET_IDT_ENTRY(idt[i], reserved);
}
// /* set 20 idt entries for exceptions */
init_exception();
// set idt entry for RTC
{
idt[RTC_ENTRY].seg_selector = KERNEL_CS; // set up elements in the RTC entry
idt[RTC_ENTRY].reserved4 = 0;
idt[RTC_ENTRY].reserved3 = 0;
idt[RTC_ENTRY].reserved2 = 1;
idt[RTC_ENTRY].reserved1 = 1;
idt[RTC_ENTRY].size = 1;
idt[RTC_ENTRY].reserved0 = 0;
idt[RTC_ENTRY].dpl = 0;
idt[RTC_ENTRY].present = 1;
SET_IDT_ENTRY(idt[RTC_ENTRY], rtc_wrapper); // set idt entry for RTC
}
// set idt entry for keyboard
{
idt[KEYBRD_ENTRY].seg_selector = KERNEL_CS; // set up elements in the keyboard entry
idt[KEYBRD_ENTRY].reserved4 = 0;
idt[KEYBRD_ENTRY].reserved3 = 0;
idt[KEYBRD_ENTRY].reserved2 = 1;
idt[KEYBRD_ENTRY].reserved1 = 1;
idt[KEYBRD_ENTRY].size = 1;
idt[KEYBRD_ENTRY].reserved0 = 0;
idt[KEYBRD_ENTRY].dpl = 0;
idt[KEYBRD_ENTRY].present = 1;
SET_IDT_ENTRY(idt[KEYBRD_ENTRY], keybrd_wrapper); // set idt entry for keyboard
}
//set idt entry for system call
{
idt[SYSCALL_ENTRY].seg_selector = KERNEL_CS;
idt[SYSCALL_ENTRY].reserved4 = 0;
idt[SYSCALL_ENTRY].reserved3 = 0;
idt[SYSCALL_ENTRY].reserved2 = 1;
idt[SYSCALL_ENTRY].reserved1 = 1;
idt[SYSCALL_ENTRY].size = 1;
idt[SYSCALL_ENTRY].reserved0 = 0;
idt[SYSCALL_ENTRY].dpl = 3;
idt[SYSCALL_ENTRY].present = 1;
SET_IDT_ENTRY(idt[SYSCALL_ENTRY], syscall_wrapper);
}
{
idt[MOUSE_VECTOR].seg_selector = KERNEL_CS;
idt[MOUSE_VECTOR].reserved4 = 0;
idt[MOUSE_VECTOR].reserved3 = 0;
idt[MOUSE_VECTOR].reserved2 = 1;
idt[MOUSE_VECTOR].reserved1 = 1;
idt[MOUSE_VECTOR].size = 1;
idt[MOUSE_VECTOR].reserved0 = 0;
idt[MOUSE_VECTOR].dpl = 0;
idt[MOUSE_VECTOR].present = 1;
SET_IDT_ENTRY(idt[MOUSE_VECTOR], mouse_linkage);
}
// set idt entry for pit
{
idt[PIT_ENTRY].seg_selector = KERNEL_CS;
idt[PIT_ENTRY].reserved4 = 0;
idt[PIT_ENTRY].reserved3 = 0;
idt[PIT_ENTRY].reserved2 = 1;
idt[PIT_ENTRY].reserved1 = 1;
idt[PIT_ENTRY].size = 1;
idt[PIT_ENTRY].reserved0 = 0;
idt[PIT_ENTRY].dpl = 3;
idt[PIT_ENTRY].present = 1;
SET_IDT_ENTRY(idt[PIT_ENTRY], pit_wrapper);
}
/////////////////////////////////
// keyboard_handler();
// test divide_error
// i=1/0;
// initialize devices
// enable associated interrupts on PIC
/* devices initialization ends*/
/* Initialize devices, memory, filesystem, enable device interrupts on the
* PIC, any other initialization stuff... */
/* Enable interrupts */
/* Do not enable the following until after you have set up your
* IDT correctly otherwise QEMU will triple fault and simple close
* without showing you any output */
i8259_init(); /* Init the PIC */
// printf("Enabling Interrupts\n");
paging_init(); // set up paging
//testing purpose of paging
// uint8_t * test_ptr = 0x000B8000;
// * test_ptr = 1;
// // uint8_t * test_ptr = 0xB6000;
// *test_ptr = 1;
// printf("paging works!!\n");
// clear();
sche_init();
pit_init();
rtc_init(); // init rtc
keybrd_init();
init_mouse();
fs_init(file_system_start); // init file system, test case: test_fs_init() is commented in the fs_init function
//sche_init();
for(i = 0; i < 30; i++){
pid_status[i] = 0;
}
pid = -1;
// enable interrupts on processor
/*****test cases*****/
// uint8_t* filename;
/*test rtc open*/
// rtc_open(filename);
/*test rtc write*/
// int32_t fd;
// uint8_t* buf;
// rtc_write(fd, buf, 2);
// // /*test rtc read*/
// while(1){
// rtc_read(fd, buf, 16);
// printf("rtc_read\n");
// }
//test_dir_read();
// read_test_text(); // read file depends on the READ_TEXT and READ_TXT flag on the top of file_system_driver.c
//read_test_exe();
/*****test cases*****/
//puts("here",1);
enable_irq(8); //enable rtc interrupt
enable_irq(1); //enable keyboard interrupt
enable_irq(0);
sti();
//while(1){
/*
printf("here\n");
dentry_t tmp_dentry;
uint32_t tmp_eip, user_esp;
uint8_t buf[4];
read_dentry_by_name((uint8_t*)"testprint", &tmp_dentry);
read_data(tmp_dentry.inode_num, 0, (uint8_t*)(0x08048000), 0x400000);
read_data(tmp_dentry.inode_num, 24, buf, 4);
printf("here2\n");
tmp_eip = 0x080481a4;
user_esp = 0x8000000 + 0x400000 - 4; //user space stack = 132MB - 4B
tss.esp0 =0x800000-4; //kernel stack = 128MB - 4B
tss.ss0 = KERNEL_DS;
asm volatile (" \n\
cli \n\
movw %0, %%ax \n\
movw %%ax, %%ds \n\
pushl %0 \n\
pushl %1 \n\
pushfl \n\
popl %%eax \n\
orl %2, %%eax \n\
pushl %%eax \n\
pushl %3 \n\
pushl %4 \n\
iret \n\
"
:
:"i"(USER_DS), "r"(user_esp), "r"(0x200), "i"(USER_CS), "r"(tmp_eip)
:"eax", "memory"
);
*/
//}
execute((uint8_t *) "shell");
while(1){
}
/* Spin (nicely, so we don't chew up cycles) */
// uint8_t test_read_buffer[TEST_READ_BUFFER_SIZE]; //initialize buffer for testing terminal_read
// uint8_t test_write_buffer[TEST_WRITE_BUFFER_SIZE] = "teststringforwritefunction\n"; //initialize buffer for testing terminal_write
// while(1){
// memset(test_read_buffer, 0, TEST_READ_BUFFER_SIZE);
// printf("Number of bytes read: %d\n", terminal_read(0, test_read_buffer, TEST_READ_BUFFER_SIZE-1)); //testing terminal_read
// terminal_write(1, test_read_buffer, TEST_READ_BUFFER_SIZE); //testing terminal _write
// terminal_write(1, test_write_buffer, TEST_WRITE_BUFFER_SIZE);
// }
asm volatile(".1: hlt; jmp .1;");
}
