main()
{
char name[64]; int pid, cmd;
char c;
while(1){
color = 0x0C;
printf("----------------------------------------------\n");
pid = getpid();
printf("I am proc %d in U mode: running segment=%x\n", pid, getcs());
show_menu();
printf("Command ? ");
gets(name);
if (name[0]==0)
continue;
cmd = find_cmd(name);
switch(cmd){
case 0 : getpid(); break;
case 1 : ps(); break;
case 2 : chname(); break;
case 3 : kfork(); break;
case 4 : kswitch(); break;
case 5 : wait(); break;
case 6 : exit(); break;
case 7 : c = kgetc(); putc(c); putc('\n'); putc('\r'); break;
case 8 : kputc(); break;
default: invalid(name); break;
}
}
}
static int kio_skip_spaces(KFILE *stream)
{
int read = 0;
int c = kgetc(stream);
while (c != EOKF)
{
++read;
if (!kio_isspace((unsigned char)c))
{
kungetc(c, stream);
--read;
break;
}
c = kgetc(stream);
}
return read;
}
//static void inr_statement(void)
void inr_statement(void)
{
long var;
accept(TOKENIZER_INR);
var = tokenizer_variable_num();
accept(TOKENIZER_VARIABLE);
ubasic_set_variable(var, kgetc());
accept(TOKENIZER_CR);
}
int update_input()
{
int c = kgetc();
switch(c) {
case '\r':
c = '\n';
kputc(c);
return c;
break;
case '\b':
/*
kputc('\b');
kputc(' ');
kputc('\b');
*/
return '\b';
case 27:
c = kgetc();
if (c == 91) {
switch (kgetc()) {
case 'D': return ARROW_LEFT;
case 'C': return ARROW_RIGHT;
case 'A': return ARROW_UP;
case 'B': return ARROW_DOWN;
default : return BAD_CODE;
}
} else {
return BAD_CODE;
}
default:
break;
}
kputc(c);
/*if (!isalpha(c) && !isdigit(c)) {
printk("<%d>", c);
}*/
return c;
}
//static void input_statement(void)
void input_statement(void)
{
long var;
char c;
accept(TOKENIZER_INPUT);
var = tokenizer_variable_num();
accept(TOKENIZER_VARIABLE);
ubasic_clear_strig(var);
while(c != '\n'){
if((c = kgetc()) != 0){
ubasic_set_string(var, c);
}
}
accept(TOKENIZER_CR);
}
//static void inp_statement(void)
void inp_statement(void)
{
long var;
char c;
int flg = 0;
accept(TOKENIZER_INP);
var = tokenizer_variable_num();
accept(TOKENIZER_VARIABLE);
while(flg == 0){
if((c = kgetc()) != 0){
ubasic_set_variable(var, c);
flg = 1;
}
}
accept(TOKENIZER_CR);
}
/**
* Create a debug terminal for testing Bluetooth.
*/
void ksimpleterminal( void )
{
int c;
led_on();
for( ;; )
{
c = kgetc( (void *)0 );
if( c != SYSERR )
kputc( (void *)0, c );
led_off();
if( c == 'q' )
break;
}
}
/*
* terminal interrupt
*
* NB: this terrible crap is xv6's code, I use it temporary
* unless virtual consoles will be done, which
* will change all tty subsystem
*/
void ttyint(void)
{
register int c;
register struct tty *tty1;
for (tty1 = tty + 1; (c = (kgetc() & 0xff)) > 0; ) {
switch (c) {
case c('U'):
while (tty1->ed != tty1->wr &&
tty1->bf[(tty1->ed - 1) % TTYBC] != '\n') {
tty1->ed--;
kputc('\x7f');
}
break;
case c('L'):
cls();
break;
case c('H'):
case '\x7f':
if (tty1->ed != tty1->wr) {
tty1->ed--;
kputc('\x7f');
}
break;
default:
if (c != 0 && tty1->ed - tty1->rd < TTYBC) {
c = (c == '\r') ? '\n' : c;
tty1->bf[tty1->ed++ % TTYBC] = c;
if (c != c('D'))
kputc(c);
if (c == '\n' || c == c('D') ||
tty1->ed == tty1->rd + TTYBC) {
tty1->wr = tty1->ed;
wakeup(&tty1->rd);
}
}
break;
}
}
}
/**
* testcases - called after initialization completes to test things.
*/
void testcases(void)
{
int c, pid;
kprintf("0) Test creation of one process\r\n");
kprintf("1) Test passing of many args\r\n");
kprintf("2) Create three processes and run them\r\n");
kprintf("3) Create 2 testbigargs processes, one maintest and a printfib\r\n");
kprintf("===TEST BEGIN===");
// TODO: Test your operating system!
c = kgetc();
switch(c)
{
case '0':
pid = create((void *)testmain, INITSTK, "MAIN1", 2, 0, NULL);
printpcb(pid);
break;
case '1':
pid = create((void *)testbigargs, INITSTK, "MAIN1", 8,
0x11111111, 0x22222222, 0x33333333, 0x44444444,
0x55555555, 0x66666666, 0x77777777, 0x88888888);
printpcb(pid);
// TODO: print out stack with extra args
kprintf("\r\nStack:\r\n");
pcb *ppcb = &proctab[pid];
ulong *saddr = ppcb->stkptr;
ulong stkhi = ((ulong)ppcb->stkbase) + ppcb->stklen;
int i;
for (i=0; i < (stkhi - ((ulong)ppcb->stkptr))/sizeof(ulong); i++)
{
kprintf("0x%08X:\t0x%08X\r\n", saddr, *saddr);
saddr++;
}
// TODO:
ready(pid, 0);
break;
case '2':
// Create three copies of a process, and let them play.
ready(create((void *)main, INITSTK, "MAIN1", 2, 0, NULL), 0);
ready(create((void *)main, INITSTK, "MAIN2", 2, 0, NULL), 0);
ready(create((void *)main, INITSTK, "MAIN3", 2, 0, NULL), 0);
while (numproc > 1) resched();
break;
default:
// Create different processes
ready(create((void *)main, INITSTK, "MAIN", 2, 0, NULL), 0);
ready(create((void *)testbigargs, INITSTK, "Big args1", 8,
0x11111111, 0x22222222, 0x33333333, 0x44444444,
0x55555555, 0x66666666, 0x77777777, 0x88888888), 0);
ready(create((void *)testbigargs, INITSTK, "Big args2", 10,
0x12345678, 0xABCDEF12, 0x11223344, 0x99999999,
0x98765432, 0xFEDCBABC, 0xFF00FF00, 0xAAAAAAAA), 0);
ready(create((void *)printfib, INITSTK, "fib", 1, 10), 0);
}
kprintf("\r\n===TEST END===\r\n");
return;
}
static void kexec_from_uart(int uartdev)
{
#ifdef _XINU_PLATFORM_ARM_RPI_
irqmask im;
device *uart;
ulong size;
void *kernel;
uchar *p;
ulong n;
im = disable();
uart = (device*)&devtab[uartdev];
/* Tell raspbootcom to send the new kernel. */
kputc('\x03', uart);
kputc('\x03', uart);
kputc('\x03', uart);
/* Receive size of the new kernel. */
for (;;)
{
size = (ulong)kgetc(uart);
size |= (ulong)kgetc(uart) << 8;
size |= (ulong)kgetc(uart) << 16;
size |= (ulong)kgetc(uart) << 24;
if (size <= 99999999 && size != 0)
{
break;
}
/* Tell raspbootcom to re-send the size. */
kputc('S', uart);
kputc('E', uart);
}
/* Tell raspbootcom the size was successfully received. */
kputc('O', uart);
kputc('K', uart);
/* Allocate buffer for new kernel. */
kernel = memget(size);
if (kernel == (void*)SYSERR)
{
return;
}
/* Load new kernel over the UART, placing it into the buffer. */
p = kernel;
n = size;
while (n--)
{
*p++ = kgetc(uart);
}
/* Execute the new kernel. */
kexec(kernel, size);
/* The following code should never actually be reached. */
memfree(kernel, size);
restore(im);
#else /* _XINU_PLATFORM_ARM_RPI_ */
fprintf(stderr, "ERROR: kexec from UART not supported on this platform.\n");
#endif /* !_XINU_PLATFORM_ARM_RPI_ */
}
static void
next_line(void)
{
bool abortCommand = false;
#if USE_SCROLLING
// TODO: scrolling is usually too slow; we could probably just remove it
if (sScreen.y == sScreen.rows - 1)
scroll_up();
else
sScreen.y++;
#else
if (in_command_invocation())
sScreen.in_command_rows++;
else
sScreen.in_command_rows = 0;
if (sScreen.paging && ((sScreen.in_command_rows > 0
&& ((sScreen.in_command_rows + 3) % sScreen.rows) == 0)
|| (sScreen.boot_debug_output && sScreen.y == sScreen.rows - 1))) {
if (sScreen.paging_timeout)
spin(1000 * 1000 * 3);
else {
// Use the paging mechanism: either, we're in the debugger, and a
// command is being executed, or we're currently showing boot debug
// output
const char *text = in_command_invocation()
? "Press key to continue, Q to quit, S to skip output"
: "Press key to continue, S to skip output, P to disable paging";
int32 length = strlen(text);
if (sScreen.x + length > sScreen.columns) {
// make sure we don't overwrite too much
text = "P";
length = 1;
}
for (int32 i = 0; i < length; i++) {
// yellow on black (or reverse, during boot)
sModule->put_glyph(sScreen.columns - length + i, sScreen.y,
text[i], sScreen.boot_debug_output ? 0x6f : 0xf6);
}
char c = kgetc();
if (c == 's') {
sScreen.ignore_output = true;
} else if (c == 'q' && in_command_invocation()) {
abortCommand = true;
sScreen.ignore_output = true;
} else if (c == 'p' && !in_command_invocation())
sScreen.paging = false;
else if (c == 't' && !in_command_invocation())
sScreen.paging_timeout = true;
// remove on screen text again
sModule->fill_glyph(sScreen.columns - length, sScreen.y, length,
1, ' ', sScreen.attr);
}
if (sScreen.in_command_rows > 0)
sScreen.in_command_rows += 2;
}
if (sScreen.y == sScreen.rows - 1) {
sScreen.y = 0;
sModule->fill_glyph(0, 0, sScreen.columns, 2, ' ', sScreen.attr);
} else
sScreen.y++;
#endif
#if NO_CLEAR
if (sScreen.y + 2 < sScreen.rows) {
sModule->fill_glyph(0, (sScreen.y + 2) % sScreen.rows, sScreen.columns,
1, ' ', sScreen.attr);
}
#endif
sScreen.x = 0;
if (abortCommand) {
abort_debugger_command();
// should not return
}
}
