static int
parse()
{
char *arg = cmd;
char *ep, *p, *q;
char unit;
size_t len;
const char *cp;
#if 0
int c, i, j;
#else
int c, i;
#endif
while ((c = *arg++)) {
if (c == ' ' || c == '\t' || c == '\n')
continue;
for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
ep = p;
if (*p)
*p++ = 0;
if (c == '-') {
while ((c = *arg++)) {
if (c == 'P') {
cp = "yes";
#if 0
} else {
opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL);
cp = "no";
}
#endif
printf("Keyboard: %s\n", cp);
continue;
#if 0
} else if (c == 'S') {
j = 0;
while ((unsigned int)(i = *arg++ - '0') <= 9)
j = j * 10 + i;
if (j > 0 && i == -'0') {
comspeed = j;
break;
}
/* Fall through to error below ('S' not in optstr[]). */
#endif
}
for (i = 0; c != optstr[i]; i++)
if (i == NOPT - 1)
return -1;
opts ^= OPT_SET(flags[i]);
}
ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
#if 0
if (ioctrl & IO_SERIAL) {
if (sio_init(115200 / comspeed) != 0)
ioctrl &= ~IO_SERIAL;
}
#endif
} else {
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
//+
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
int option_detect(int argc, char **argv, struct option_info *info){
int i;
for(i=1;i<argc;i++){
OPT_CHECK(command, argv[i], info);
OPT_CHECK(mode, argv[i], info);
OPT_CHECK(type, argv[i], info);
OPT_CHECK(debounce, argv[i], info);
OPT_CHECK(handler, argv[i], info);
printf("unknown option: %s\n",argv[i]);
return -1;
}
switch(info->command){
case OPT_SET:
if(info->gpio_no == COM_SUB_ALL) NOT_MATCH_OPT(command);
switch(info->mode){
case MODE_SUB_INPUT:
switch(info->type){
case TYPE_SUB_LOW:
case TYPE_SUB_HIGH:
NOT_MATCH_OPT(type);
return -1;
}
if(info->handler == NULL){
if(info->type){ IGNORE_OPT(type, info); }
if(info->debounce) { IGNORE_OPT(debounce, info); }
}
break;
case MODE_SUB_OUTPUT:
switch(info->type){
case TYPE_SUB_LOW_LEVEL:
case TYPE_SUB_HIGH_LEVEL:
case TYPE_SUB_FALLING_EDGE:
case TYPE_SUB_RISING_EDGE:
NOT_MATCH_OPT(type);
return -1;
}
if(info->debounce){ IGNORE_OPT(debounce, info); }
if(info->handler){ IGNORE_OPT(handler, info); }
break;
}
break;
case OPT_GET:
if(info->mode){ IGNORE_OPT(mode, info); }
if(info->type){ IGNORE_OPT(type, info); }
if(info->debounce){ IGNORE_OPT(debounce, info); }
if(info->handler){ IGNORE_OPT(handler, info); }
break;
}
return 0;
}
void fold_stmt_if(stmt *s)
{
symtable *test_symtab = fold_stmt_test_init_expr(s, "if");
fold_expr(s->expr, test_symtab);
fold_need_expr(s->expr, s->f_str(), 1);
OPT_CHECK(s->expr, "constant expression in if");
fold_stmt(s->lhs);
if(s->rhs)
fold_stmt(s->rhs);
}
int
xgetc(int fn)
{
if (OPT_CHECK(RBX_NOINTR))
return (0);
for (;;) {
if (ioctrl & IO_KEYBOARD && getc(1))
return (fn ? 1 : getc(0));
if (ioctrl & IO_SERIAL && sio_ischar())
return (fn ? 1 : sio_getc());
if (fn)
return (0);
}
/* NOTREACHED */
}
void fold_stmt_for(stmt *s)
{
s->lbl_break = asm_label_flow("for_start");
s->lbl_continue = asm_label_flow("for_contiune");
if(s->flow->for_init_decls){
expr *init_exp = fold_for_if_init_decls(s);
UCC_ASSERT(!s->flow->for_init, "for init in c99 for-decl mode");
s->flow->for_init = init_exp;
}
#define FOLD_IF(x) if(x) fold_expr(x, s->flow->for_init_symtab)
FOLD_IF(s->flow->for_init);
FOLD_IF(s->flow->for_while);
FOLD_IF(s->flow->for_inc);
#undef FOLD_IF
if(s->flow->for_while){
fold_need_expr(s->flow->for_while, "for-while", 1);
OPT_CHECK(s->flow->for_while, "constant expression in for");
}
fold_stmt(s->lhs);
/*
* need an extra generation for for_init,
* since it's generated unlike other loops (symtab_new() in parse.c)
*/
gen_code_decls(s->flow->for_init_symtab);
#ifdef SYMTAB_DEBUG
fprintf(stderr, "for-code st:\n");
PRINT_STAB(s->lhs, 1);
fprintf(stderr, "for-init st:\n");
print_stab(s->flow->for_init_symtab, 0, NULL);
fprintf(stderr, "for enclosing scope st:\n");
PRINT_STAB(s, 0);
#endif
}
int
main(void)
{
int autoboot, c = 0;
ufs_ino_t ino;
dmadat = (void *)(0x20000000 + (16 << 20));
board_init();
autoboot = 1;
/* Process configuration file */
if ((ino = lookup(PATH_CONFIG)) ||
(ino = lookup(PATH_DOTCONFIG)))
fsread(ino, cmd, sizeof(cmd));
if (*cmd) {
if (parse())
autoboot = 0;
printf("%s: %s\n", PATH_CONFIG, cmd);
/* Do not process this command twice */
*cmd = 0;
}
if (*kname == '\0')
strcpy(kname, PATH_KERNEL);
/* Present the user with the boot2 prompt. */
for (;;) {
printf("\nDefault: %s\nboot: ", kname);
if (!autoboot ||
(OPT_CHECK(RBX_NOINTR) == 0 && (c = getc(2)) != 0))
getstr(c);
xputchar('\n');
autoboot = 0;
c = 0;
if (parse())
xputchar('\a');
else
load();
}
return (1);
}
int
keyhit(unsigned int secs)
{
uint32_t t0, t1;
if (OPT_CHECK(RBX_NOINTR))
return (0);
secs *= SECOND;
t0 = 0;
for (;;) {
if (xgetc(1))
return (1);
if (secs > 0) {
t1 = *(uint32_t *)PTOV(0x46c);
if (!t0)
t0 = t1;
if (t1 < t0 || t1 >= t0 + secs)
return (0);
}
}
/* NOTREACHED */
}
static int
parse()
{
char *arg = cmd;
char *ep, *p, *q;
const char *cp;
unsigned int drv;
int c, i, j;
size_t k;
while ((c = *arg++)) {
if (c == ' ' || c == '\t' || c == '\n')
continue;
for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
ep = p;
if (*p)
*p++ = 0;
if (c == '-') {
while ((c = *arg++)) {
if (c == 'P') {
if (*(uint8_t *)PTOV(0x496) & 0x10) {
cp = "yes";
} else {
opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL);
cp = "no";
}
printf("Keyboard: %s\n", cp);
continue;
#if SERIAL
} else if (c == 'S') {
j = 0;
while ((unsigned int)(i = *arg++ - '0') <= 9)
j = j * 10 + i;
if (j > 0 && i == -'0') {
comspeed = j;
break;
}
/* Fall through to error below ('S' not in optstr[]). */
#endif
}
for (i = 0; c != optstr[i]; i++)
if (i == NOPT - 1)
return -1;
opts ^= OPT_SET(flags[i]);
}
#if SERIAL
ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
if (DO_SIO) {
if (sio_init(115200 / comspeed) != 0)
ioctrl &= ~IO_SERIAL;
}
#endif
} else {
for (q = arg--; *q && *q != '('; q++);
if (*q) {
drv = -1;
if (arg[1] == ':') {
drv = *arg - '0';
if (drv > 9)
return (-1);
arg += 2;
}
if (q - arg != 2)
return -1;
for (i = 0; arg[0] != dev_nm[i][0] ||
arg[1] != dev_nm[i][1]; i++)
if (i == NDEV - 1)
return -1;
dsk.type = i;
arg += 3;
dsk.unit = *arg - '0';
if (arg[1] != ',' || dsk.unit > 9)
return -1;
arg += 2;
dsk.slice = WHOLE_DISK_SLICE;
if (arg[1] == ',') {
dsk.slice = *arg - '0' + 1;
if (dsk.slice > NDOSPART + 1)
return -1;
arg += 2;
}
if (arg[1] != ')')
return -1;
dsk.part = *arg - 'a';
if (dsk.part > 7)
return (-1);
arg += 2;
if (drv == -1)
drv = dsk.unit;
dsk.drive = (dsk.type <= TYPE_MAXHARD
? DRV_HARD : 0) + drv;
dsk_meta = 0;
}
k = ep - arg;
if (k > 0) {
if (k >= sizeof(knamebuf))
return -1;
memcpy(knamebuf, arg, k + 1);
kname = knamebuf;
}
}
arg = p;
}
return 0;
}
int
main(void)
{
uint8_t autoboot;
ufs_ino_t ino;
size_t nbyte;
dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
dsk.unit = dsk.drive & DRV_MASK;
dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1;
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
/* Process configuration file */
autoboot = 1;
if ((ino = lookup(PATH_CONFIG)) ||
(ino = lookup(PATH_DOTCONFIG))) {
nbyte = fsread(ino, cmd, sizeof(cmd) - 1);
cmd[nbyte] = '\0';
}
if (*cmd) {
memcpy(cmddup, cmd, sizeof(cmd));
if (parse())
autoboot = 0;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmddup);
/* Do not process this command twice */
*cmd = 0;
}
/*
* Try to exec stage 3 boot loader. If interrupted by a keypress,
* or in case of failure, try to load a kernel directly instead.
*/
if (!kname) {
kname = PATH_BOOT3;
if (autoboot && !keyhit(3*SECOND)) {
load();
kname = PATH_KERNEL;
}
}
/* Present the user with the boot2 prompt. */
for (;;) {
if (!autoboot || !OPT_CHECK(RBX_QUIET))
printf("\nFreeBSD/x86 boot\n"
"Default: %u:%s(%u,%c)%s\n"
"boot: ",
dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
'a' + dsk.part, kname);
if (DO_SIO)
sio_flush();
if (!autoboot || keyhit(3*SECOND))
getstr();
else if (!autoboot || !OPT_CHECK(RBX_QUIET))
putchar('\n');
autoboot = 0;
if (parse())
putchar('\a');
else
load();
}
}
int
main(void)
{
int autoboot;
ino_t ino;
dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
dsk.unit = dsk.drive & DRV_MASK;
dsk.part = -1;
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */
bootinfo.bi_extmem = memsize();
bootinfo.bi_memsizes_valid++;
/* Process configuration file */
autoboot = 1;
if ((ino = lookup(PATH_CONFIG)))
fsread(ino, cmd, sizeof(cmd));
if (*cmd) {
memcpy(cmddup, cmd, sizeof(cmd));
if (parse())
autoboot = 0;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmddup);
/* Do not process this command twice */
*cmd = 0;
}
/*
* Try to exec stage 3 boot loader. If interrupted by a keypress,
* or in case of failure, try to load a kernel directly instead.
*/
if (autoboot && !*kname) {
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
if (!keyhit(3*SECOND)) {
load();
memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
}
}
/* Present the user with the boot2 prompt. */
for (;;) {
if (!autoboot || !OPT_CHECK(RBX_QUIET))
printf("\nFreeBSD/x86 boot\n"
"Default: %u:%s(%up%u)%s\n"
"boot: ",
dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
dsk.part, kname);
if (ioctrl & IO_SERIAL)
sio_flush();
if (!autoboot || keyhit(5*SECOND))
getstr();
else if (!autoboot || !OPT_CHECK(RBX_QUIET))
putchar('\n');
autoboot = 0;
if (parse())
putchar('\a');
else
load();
}
}
int
main(u_int argc, const char *argv[], const char *envv[], uint64_t memsize)
{
uint8_t autoboot;
ufs_ino_t ino;
size_t nbyte;
/* Arguments from Miniboot. */
beri_argc = argc;
beri_argv = argv;
beri_envv = envv;
beri_memsize = memsize;
dmadat = &__dmadat;
#if 0
/* XXXRW: more here. */
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
#endif
dsk.type = TYPE_DEFAULT;
#if 0
dsk.unit = dsk.drive & DRV_MASK;
dsk.slice = *(uint8_t *)PTOV(ARGS + 1) + 1;
#endif
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
/* Process configuration file */
autoboot = 1;
if ((ino = lookup(PATH_CONFIG)) ||
(ino = lookup(PATH_DOTCONFIG))) {
nbyte = fsread(ino, cmd, sizeof(cmd) - 1);
cmd[nbyte] = '\0';
}
if (*cmd) {
memcpy(cmddup, cmd, sizeof(cmd));
if (parse())
autoboot = 0;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmddup);
/* Do not process this command twice */
*cmd = 0;
}
/*
* Try to exec stage 3 boot loader. If interrupted by a keypress,
* or in case of failure, try to load a kernel directly instead.
*/
if (!kname) {
kname = PATH_LOADER;
if (autoboot && !keyhit(3*SECOND)) {
boot_fromfs();
kname = PATH_KERNEL;
}
}
/* Present the user with the boot2 prompt. */
for (;;) {
if (!autoboot || !OPT_CHECK(RBX_QUIET))
printf("\nFreeBSD/mips boot\n"
"Default: %s%ju:%s\n"
"boot: ",
dev_nm[dsk.type], dsk.unitptr, kname);
#if 0
if (ioctrl & IO_SERIAL)
sio_flush();
#endif
if (!autoboot || keyhit(3*SECOND))
getstr();
else if (!autoboot || !OPT_CHECK(RBX_QUIET))
putchar('\n');
autoboot = 0;
if (parse())
putchar('\a');
else
load();
}
}
static int
parse(char *cmdstr, int *dskupdated)
{
char *arg = cmdstr;
char *ep, *p, *q;
const char *cp;
unsigned int drv;
int c, i, j;
*dskupdated = 0;
while ((c = *arg++)) {
if (c == ' ' || c == '\t' || c == '\n')
continue;
for (p = arg; *p && *p != '\n' && *p != ' ' && *p != '\t'; p++);
ep = p;
if (*p)
*p++ = 0;
if (c == '-') {
while ((c = *arg++)) {
if (c == 'P') {
if (*(uint8_t *)PTOV(0x496) & 0x10) {
cp = "yes";
} else {
opts |= OPT_SET(RBX_DUAL) | OPT_SET(RBX_SERIAL);
cp = "no";
}
printf("Keyboard: %s\n", cp);
continue;
} else if (c == 'S') {
j = 0;
while ((unsigned int)(i = *arg++ - '0') <= 9)
j = j * 10 + i;
if (j > 0 && i == -'0') {
comspeed = j;
break;
}
/* Fall through to error below ('S' not in optstr[]). */
}
for (i = 0; c != optstr[i]; i++)
if (i == NOPT - 1)
return -1;
opts ^= OPT_SET(flags[i]);
}
ioctrl = OPT_CHECK(RBX_DUAL) ? (IO_SERIAL|IO_KEYBOARD) :
OPT_CHECK(RBX_SERIAL) ? IO_SERIAL : IO_KEYBOARD;
if (ioctrl & IO_SERIAL) {
if (sio_init(115200 / comspeed) != 0)
ioctrl &= ~IO_SERIAL;
}
} else {
for (q = arg--; *q && *q != '('; q++);
if (*q) {
drv = -1;
if (arg[1] == ':') {
drv = *arg - '0';
if (drv > 9)
return (-1);
arg += 2;
}
if (q - arg != 2)
return -1;
for (i = 0; arg[0] != dev_nm[i][0] ||
arg[1] != dev_nm[i][1]; i++)
if (i == NDEV - 1)
return -1;
dsk.type = i;
arg += 3;
dsk.unit = *arg - '0';
if (arg[1] != 'p' || dsk.unit > 9)
return -1;
arg += 2;
dsk.part = *arg - '0';
if (dsk.part < 1 || dsk.part > 9)
return -1;
arg++;
if (arg[0] != ')')
return -1;
arg++;
if (drv == -1)
drv = dsk.unit;
dsk.drive = (dsk.type <= TYPE_MAXHARD
? DRV_HARD : 0) + drv;
*dskupdated = 1;
}
if ((i = ep - arg)) {
if ((size_t)i >= sizeof(kname))
return -1;
memcpy(kname, arg, i + 1);
}
}
arg = p;
}
return 0;
}
int
main(void)
{
char cmd[512], cmdtmp[512];
int autoboot, dskupdated;
ufs_ino_t ino;
dmadat = (void *)(roundup2(__base + (int32_t)&_end, 0x10000) - __base);
v86.ctl = V86_FLAGS;
v86.efl = PSL_RESERVED_DEFAULT | PSL_I;
dsk.drive = *(uint8_t *)PTOV(ARGS);
dsk.type = dsk.drive & DRV_HARD ? TYPE_AD : TYPE_FD;
dsk.unit = dsk.drive & DRV_MASK;
dsk.part = -1;
dsk.start = 0;
bootinfo.bi_version = BOOTINFO_VERSION;
bootinfo.bi_size = sizeof(bootinfo);
bootinfo.bi_basemem = 0; /* XXX will be filled by loader or kernel */
bootinfo.bi_extmem = memsize();
bootinfo.bi_memsizes_valid++;
/* Process configuration file */
if (gptinit() != 0)
return (-1);
autoboot = 1;
*cmd = '\0';
for (;;) {
*kname = '\0';
if ((ino = lookup(PATH_CONFIG)) ||
(ino = lookup(PATH_DOTCONFIG)))
fsread(ino, cmd, sizeof(cmd));
if (*cmd != '\0') {
memcpy(cmdtmp, cmd, sizeof(cmdtmp));
if (parse(cmdtmp, &dskupdated))
break;
if (dskupdated && gptinit() != 0)
break;
if (!OPT_CHECK(RBX_QUIET))
printf("%s: %s", PATH_CONFIG, cmd);
*cmd = '\0';
}
if (autoboot && keyhit(3)) {
if (*kname == '\0')
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
break;
}
autoboot = 0;
/*
* Try to exec stage 3 boot loader. If interrupted by a
* keypress, or in case of failure, try to load a kernel
* directly instead.
*/
if (*kname != '\0')
load();
memcpy(kname, PATH_BOOT3, sizeof(PATH_BOOT3));
load();
memcpy(kname, PATH_KERNEL, sizeof(PATH_KERNEL));
load();
gptbootfailed(&dsk);
if (gptfind(&freebsd_ufs_uuid, &dsk, -1) == -1)
break;
dsk_meta = 0;
}
/* Present the user with the boot2 prompt. */
for (;;) {
if (!OPT_CHECK(RBX_QUIET)) {
printf("\nFreeBSD/x86 boot\n"
"Default: %u:%s(%up%u)%s\n"
"boot: ",
dsk.drive & DRV_MASK, dev_nm[dsk.type], dsk.unit,
dsk.part, kname);
}
if (ioctrl & IO_SERIAL)
sio_flush();
*cmd = '\0';
if (keyhit(0))
getstr(cmd, sizeof(cmd));
else if (!OPT_CHECK(RBX_QUIET))
putchar('\n');
if (parse(cmd, &dskupdated)) {
putchar('\a');
continue;
}
if (dskupdated && gptinit() != 0)
continue;
load();
}
/* NOTREACHED */
}
