static void conf_choice(struct menu *menu)
{
const char *prompt = menu_get_prompt(menu);
struct menu *child;
struct symbol *active;
while (1) {
current_menu = menu;
active = sym_get_choice_value(menu->sym);
cdone(); cinit();
for (child = menu->list; child; child = child->next) {
if (!menu_is_visible(child))
continue;
cmake();
cprint_tag("%p", child);
cprint_name("%s", menu_get_prompt(child));
items[item_no - 1]->selected = (child->sym == active);
}
switch (dialog_checklist(prompt ? prompt : "Main Menu",
radiolist_instructions, 15, 70, 6,
item_no, items, FLAG_RADIO)) {
case 0:
if (sscanf(first_sel_item(item_no, items)->tag, "%p", &menu) != 1)
break;
sym_set_tristate_value(menu->sym, yes);
return;
case 1:
show_help(menu);
break;
case 255:
return;
}
}
}
int main() {
arma::mat rawdata;
rawdata.load(data.c_str());
arma::mat X;
X=rawdata(arma::span(0, numExp-1), arma::span(0, numFeat-1));
int m = numExp;
int n = numFeat;
arma::mat mu(nCl,n);
mu.randu();
//bring inital mu into correct range
for (int i=0; i<n; i++) {
mu.col(i) = X.col(i).min() + (X.col(i).max()-X.col(i).min())*mu.col(i);
}
arma::mat cinit(nCl,1);
cinit.zeros();
arma::mat cloop;
arma::mat c(m,1); //vector which assign each example to a cluster
int numC;
for (int k=0; k<numIter; k++) {
//E-Step:
c.zeros();
for (int i=0; i<m; i++) {
cloop = cinit;
for (int j=0; j<nCl; j++) {
cloop.row(j) = (X.row(i)-mu.row(j))*trans(X.row(i)-mu.row(j));
}
c.row(i) = cloop.index_min();
}
//M-Step:
mu.zeros();
for (int j=0; j<nCl; j++) {
numC=0;
for (int i=0; i<m; i++) {
if (c(i,0)==j) {
numC += 1;
mu.row(j) += X.row(i);
}
}
if(numC==0) {mu.row(j).zeros();} //no training examples were assigned to this cluster (maybe too many clusters?)
mu.row(j) = mu.row(j)/numC;
}
}
//output data files to be used for plotting
std::ofstream of_X("X_kMeans.out");
std::ofstream of_c("c_kMeans.out");
std::ofstream of_mu("mu_kMeans.out");
for (int i=0;i<X.n_rows;i++) {
of_X << X.row(i) << std::endl;
of_c << c.row(i) << std::endl;
}
for (int i=0;i<mu.n_rows;i++) {
of_mu << mu.row(i) << std::endl;
}
}
int
main(void)
{
unsigned timeout = 0;
/* do board-specific initialisation */
board_init();
#ifdef INTERFACE_USART
/* XXX sniff for a USART connection to decide whether to wait in the bootloader? */
timeout = BOOTLOADER_DELAY;
#endif
#ifdef INTERFACE_I2C
# error I2C bootloader detection logic not implemented
#endif
/* if the app left a cookie saying we should wait, then wait */
if (should_wait())
timeout = BOOTLOADER_DELAY;
#ifdef BOARD_FORCE_BL_PIN
/* if the force-BL pin state matches the state of the pin, wait in the bootloader forever */
if (BOARD_FORCE_BL_VALUE == gpio_get(BOARD_FORCE_BL_PORT, BOARD_FORCE_BL_PIN))
timeout = 0xffffffff;
#endif
/* look for the magic wait-in-bootloader value in backup register zero */
/* if we aren't expected to wait in the bootloader, try to boot immediately */
if (timeout == 0) {
/* try to boot immediately */
jump_to_app();
/* if we returned, there is no app; go to the bootloader and stay there */
timeout = 0;
}
/* configure the clock for bootloader activity */
rcc_clock_setup_in_hsi_out_24mhz();
/* start the interface */
cinit(BOARD_INTERFACE_CONFIG);
while (1)
{
/* run the bootloader, possibly coming back after the timeout */
bootloader(timeout);
/* look to see if we can boot the app */
jump_to_app();
/* boot failed; stay in the bootloader forever next time */
timeout = 0;
}
}
extern "C" void
cinit_(fint *N, fint *M, freal *X0, freal *BL, freal *BU, freal *INF,
fbool *EQUATN, fbool *LINEAR, freal *V0, freal *CL, freal *CU,
fbool *EFIRST, fbool *LFIRST, fbool *NVFRST)
{
cinit(N, M, X0, BL, BU, INF,
EQUATN, LINEAR, V0, CL, CU,
EFIRST, LFIRST, NVFRST);
}
void
main(int argc, char *argv[])
{
char *p;
int c;
thechar = '5';
thestring = "arm";
ensuresymb(NSYMB);
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
setinclude(".");
ARGBEGIN {
default:
c = ARGC();
if(c >= 0 || c < sizeof(debug))
debug[c] = 1;
break;
case 'o':
outfile = ARGF();
break;
case 'D':
p = ARGF();
if(p) {
if (nDlist%8 == 0)
Dlist = allocn(Dlist, nDlist*sizeof(char *),
8*sizeof(char *));
Dlist[nDlist++] = p;
}
break;
case 'I':
p = ARGF();
setinclude(p);
break;
case 't':
thechar = 't';
thestring = "thumb";
break;
} ARGEND
if(*argv == 0) {
print("usage: %ca [-options] file.s\n", thechar);
errorexit();
}
if(argc > 1){
print("can't assemble multiple files\n");
errorexit();
}
if(assemble(argv[0]))
errorexit();
exits(0);
}
/*
* Initialization code.
* Called from cold start routine as
* soon as a stack and segmentation
* have been established.
* Functions:
* clear and free user core
* turn on clock
* hand craft 0th process
* call all initialization routines
* fork - process 0 to schedule
* - process 1 execute bootstrap
*
* loop at low address in user mode -- /etc/init
* cannot be executed.
*/
main()
{
startup();
/*
* set up system process
*/
#ifdef PDP11
proc[0].p_addr = ka6->r[0];
#endif
proc[0].p_addr = cpaddr;
proc[0].p_size = USIZE;
proc[0].p_stat = SRUN;
proc[0].p_flag |= SLOAD|SSYS;
proc[0].p_nice = NZERO;
u.u_procp = &proc[0];
u.u_cmask = CMASK;
/*
* Initialize devices and
* set up 'known' i-nodes
*/
clkstart();
cinit();
binit();
iinit();
rootdir = iget(rootdev, (ino_t)ROOTINO);
rootdir->i_flag &= ~ILOCK;
u.u_cdir = iget(rootdev, (ino_t)ROOTINO);
u.u_cdir->i_flag &= ~ILOCK;
u.u_rdir = NULL;
/*
* make init process
* enter scheduling loop
* with system process
*/
if(newproc()) {
expand(USIZE + (int)btoc(szicode));
#ifdef PDP11
estabur((unsigned)0, btoc(szicode), (unsigned)0, 0, RO);
#endif
copyout((caddr_t)icode, (caddr_t)0, szicode);
/*
* Return goes to loc. 0 of user init
* code just copied out.
*/
return;
}
sched();
}
void
main(int argc, char *argv[])
{
char *p;
thechar = '6';
thestring = "amd64";
// Allow GOARCH=thestring or GOARCH=thestringsuffix,
// but not other values.
p = getgoarch();
if(strncmp(p, thestring, strlen(thestring)) != 0)
sysfatal("cannot use %cc with GOARCH=%s", thechar, p);
if(strcmp(p, "amd64p32") == 0)
thelinkarch = &linkamd64p32;
ctxt = linknew(thelinkarch);
ctxt->diag = yyerror;
ctxt->bso = &bstdout;
ctxt->enforce_data_order = 1;
Binit(&bstdout, 1, OWRITE);
listinit6();
fmtinstall('L', Lconv);
ensuresymb(NSYMB);
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
setinclude(".");
flagfn1("D", "name[=value]: add #define", dodef);
flagfn1("I", "dir: add dir to include path", setinclude);
flagcount("S", "print assembly and machine code", &debug['S']);
flagcount("m", "debug preprocessor macros", &debug['m']);
flagstr("o", "file: set output file", &outfile);
flagstr("trimpath", "prefix: remove prefix from recorded source file paths", &ctxt->trimpath);
flagparse(&argc, &argv, usage);
ctxt->debugasm = debug['S'];
if(argc < 1)
usage();
if(argc > 1){
print("can't assemble multiple files\n");
errorexit();
}
if(assemble(argv[0]))
errorexit();
Bflush(&bstdout);
exits(0);
}
/*
* Process a single external definition
*/
extdef()
{
register o, elsize;
int type, sclass;
register struct hshtab *ds;
if(((o=symbol())==EOF) || o==SEMI)
return;
peeksym = o;
type = INT;
sclass = EXTERN;
xdflg = FNDEL;
if ((elsize = getkeywords(&sclass, &type)) == -1 && peeksym!=NAME)
goto syntax;
if (type==STRUCT)
blkhed();
do {
defsym = 0;
decl1(EXTERN, type, 0, elsize);
if ((ds=defsym)==0)
return;
funcsym = ds;
ds->hflag =| FNDEL;
outcode("BS", SYMDEF, ds->name);
xdflg = 0;
if ((ds->type&XTYPE)==FUNC) {
if ((peeksym=symbol())==LBRACE || peeksym==KEYW) {
funcblk.type = decref(ds->type);
cfunc(ds->name);
return;
}
} else
cinit(ds);
} while ((o=symbol())==COMMA);
if (o==SEMI)
return;
syntax:
if (o==RBRACE) {
error("Too many }'s");
peeksym = 0;
return;
}
error("External definition syntax");
errflush(o);
statement(0);
}
static void conf(struct menu *menu)
{
struct dialog_list_item *active_item = NULL;
struct menu *submenu;
const char *prompt = menu_get_prompt(menu);
struct symbol *sym;
char active_entry[40];
int stat, type;
unlink("lxdialog.scrltmp");
active_entry[0] = 0;
while (1) {
indent = 0;
child_count = 0;
current_menu = menu;
cdone(); cinit();
build_conf(menu);
if (!child_count)
break;
if (menu == &rootmenu) {
cmake(); cprint_tag(":"); cprint_name("--- ");
cmake(); cprint_tag("L"); cprint_name("Load an Alternate Configuration File");
cmake(); cprint_tag("S"); cprint_name("Save Configuration to an Alternate File");
}
dialog_clear();
stat = dialog_menu(prompt ? prompt : "Main Menu",
menu_instructions, rows, cols, rows - 10,
active_entry, item_no, items);
if (stat < 0)
return;
if (stat == 1 || stat == 255)
break;
active_item = first_sel_item(item_no, items);
if (!active_item)
continue;
active_item->selected = 0;
strncpy(active_entry, active_item->tag, sizeof(active_entry));
active_entry[sizeof(active_entry)-1] = 0;
type = active_entry[0];
if (!type)
continue;
sym = NULL;
submenu = NULL;
if (sscanf(active_entry + 1, "%p", &submenu) == 1)
sym = submenu->sym;
switch (stat) {
case 0:
switch (type) {
case 'm':
if (single_menu_mode)
submenu->data = (void *) (long) !submenu->data;
else
conf(submenu);
break;
case 't':
if (sym_is_choice(sym) && sym_get_tristate_value(sym) == yes)
conf_choice(submenu);
else if (submenu->prompt->type == P_MENU)
conf(submenu);
break;
case 's':
conf_string(submenu);
break;
case 'L':
conf_load();
break;
case 'S':
conf_save();
break;
}
break;
case 2:
if (sym)
show_help(submenu);
else
show_helptext("README", mconf_readme);
break;
case 3:
if (type == 't') {
if (sym_set_tristate_value(sym, yes))
break;
if (sym_set_tristate_value(sym, mod))
show_textbox(NULL, setmod_text, 6, 74);
}
break;
case 4:
if (type == 't')
sym_set_tristate_value(sym, no);
break;
case 5:
if (type == 't')
sym_set_tristate_value(sym, mod);
break;
case 6:
if (type == 't')
sym_toggle_tristate_value(sym);
else if (type == 'm')
conf(submenu);
break;
case 7:
search_conf();
break;
}
}
}
void
main(int argc, char *argv[])
{
char *p;
int nout, nproc, i, c;
thechar = '5';
thestring = "arm";
ensuresymb(NSYMB);
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
setinclude(".");
ARGBEGIN {
default:
c = ARGC();
if(c >= 0 || c < sizeof(debug))
debug[c] = 1;
break;
case 'o':
outfile = ARGF();
break;
case 'D':
p = ARGF();
if(p) {
if (nDlist%8 == 0)
Dlist = allocn(Dlist, nDlist*sizeof(char *),
8*sizeof(char *));
Dlist[nDlist++] = p;
}
break;
case 'I':
p = ARGF();
setinclude(p);
break;
case 't':
thechar = 't';
thestring = "thumb";
break;
} ARGEND
if(*argv == 0) {
print("usage: %ca [-options] file.s\n", thechar);
errorexit();
}
if(argc > 1 && systemtype(Windows)){
print("can't assemble multiple files on windows\n");
errorexit();
}
if(argc > 1 && !systemtype(Windows)) {
nproc = 1;
if(p = getenv("NPROC"))
nproc = atol(p); /* */
c = 0;
nout = 0;
for(;;) {
Waitmsg *w;
while(nout < nproc && argc > 0) {
i = fork();
if(i < 0) {
fprint(2, "fork: %r\n");
errorexit();
}
if(i == 0) {
print("%s:\n", *argv);
if(assemble(*argv))
errorexit();
exits(0);
}
nout++;
argc--;
argv++;
}
w = wait();
if(w == nil) {
if(c)
errorexit();
exits(0);
}
if(w->msg[0])
c++;
nout--;
}
}
if(assemble(argv[0]))
errorexit();
exits(0);
}
int
main(void)
{
bool try_boot = true; /* try booting before we drop to the bootloader */
unsigned timeout = BOOTLOADER_DELAY; /* if nonzero, drop out of the bootloader after this time */
/* Enable the FPU before we hit any FP instructions */
SCB_CPACR |= ((3UL << 10*2) | (3UL << 11*2)); /* set CP10 Full Access and set CP11 Full Access */
#if defined(BOARD_VRBRAINV40) || defined(BOARD_VRBRAINV45)
if(!board_test_force_pin() && !(board_get_rtc_signature() == BOOT_RTC_SIGNATURE)) {
jump_to_app();
}
#endif
/* do board-specific initialisation */
board_init();
/*
* Check the force-bootloader register; if we find the signature there, don't
* try booting.
*/
if (board_get_rtc_signature() == BOOT_RTC_SIGNATURE) {
/*
* Don't even try to boot before dropping to the bootloader.
*/
try_boot = false;
/*
* Don't drop out of the bootloader until something has been uploaded.
*/
timeout = 0;
#if defined(BOARD_VRBRAINV40) || defined(BOARD_VRBRAINV45)
// force an erase of the first sector because version 4.x
// of the board is not able to reset USB after first boot.
// This will force the bootloader to stay until a program has been flashed.
flash_unlock();
flash_func_erase_sector(0);
flash_lock();
#endif
/*
* Clear the signature so that if someone resets us while we're
* in the bootloader we'll try to boot next time.
*/
board_set_rtc_signature(0);
}
#ifdef INTERFACE_USB
/*
* Check for USB connection - if present, don't try to boot, but set a timeout after
* which we will fall out of the bootloader.
*
* If the force-bootloader pins are tied, we will stay here until they are removed and
* we then time out.
*/
#if defined(BOARD_VRBRAINV40) || defined(BOARD_VRBRAINV45)
if (gpio_get(BOARD_PRESENCE_PORT, BOARD_PRESENCE_PIN) != 0 && board_test_force_pin()) {
/* don't try booting before we set up the bootloader */
try_boot = false;
}
#else
if (gpio_get(BOARD_PRESENCE_PORT, BOARD_PRESENCE_PIN) != 0) {
/* don't try booting before we set up the bootloader */
try_boot = false;
}
#endif
#endif
/* Try to boot the app if we think we should just go straight there */
if (try_boot) {
/* set the boot-to-bootloader flag so that if boot fails on reset we will stop here */
#ifdef BOARD_BOOT_FAIL_DETECT
board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif
/* try to boot immediately */
jump_to_app();
/* booting failed, stay in the bootloader forever */
timeout = 0;
}
/* configure the clock for bootloader activity */
rcc_clock_setup_hse_3v3(&clock_setup);
/* start the interface */
cinit(BOARD_INTERFACE_CONFIG);
#if 0
// MCO1/02
gpio_mode_setup(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO8);
gpio_set_output_options(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100MHZ, GPIO8);
gpio_set_af(GPIOA, GPIO_AF0, GPIO8);
gpio_mode_setup(GPIOC, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO9);
gpio_set_af(GPIOC, GPIO_AF0, GPIO9);
#endif
while (1)
{
/* run the bootloader, come back after an app is uploaded or we time out */
bootloader(timeout);
/* if the force-bootloader pins are strapped, just loop back */
if (board_test_force_pin())
continue;
/* set the boot-to-bootloader flag so that if boot fails on reset we will stop here */
#ifdef BOARD_BOOT_FAIL_DETECT
board_set_rtc_signature(BOOT_RTC_SIGNATURE);
#endif
/* look to see if we can boot the app */
jump_to_app();
/* launching the app failed - stay in the bootloader forever */
timeout = 0;
}
}
void
main(int argc, char *argv[])
{
char ofile[100], incfile[20], *p;
int nout, nproc, status, i, c, of;
thechar = '7'; /* of 9 */
thestring = "alpha";
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
include[ninclude++] = ".";
ARGBEGIN {
default:
c = ARGC();
if(c >= 0 || c < sizeof(debug))
debug[c] = 1;
break;
case 'o':
outfile = ARGF();
break;
case 'D':
p = ARGF();
if(p)
Dlist[nDlist++] = p;
break;
case 'I':
p = ARGF();
if(p)
include[ninclude++] = p;
break;
} ARGEND
if(*argv == 0) {
print("usage: %ca [-options] file.s\n", thechar);
errorexit();
}
nproc = 3;
if(p = getenv("NPROC"))
nproc = atol(p);
if(argc > 1) {
c = 0;
nout = 0;
for(;;) {
while(nout < nproc && argc > 0) {
i = fork();
if(i < 0) {
i = mywait(&status);
if(i < 0)
errorexit();
if(status)
c++;
nout--;
continue;
}
if(i == 0) {
print("%s:\n", *argv);
goto child;
}
nout++;
argc--;
argv++;
}
i = mywait(&status);
if(i < 0) {
if(c)
errorexit();
exits(0);
}
if(status)
c++;
nout--;
}
}
child:
strecpy(ofile, ofile+sizeof ofile, *argv);
if(p = strrchr(ofile, '/')) {
include[0] = ofile;
*p++ = 0;
} else
p = ofile;
if(outfile == 0) {
outfile = p;
if(p = strrchr(outfile, '.'))
if(p[1] == 's' && p[2] == 0)
p[0] = 0;
p = strrchr(outfile, 0);
p[0] = '.';
p[1] = thechar;
p[2] = 0;
}
if(0) {
strcpy(incfile, "/usr/%include");
p = strrchr(incfile, '%');
if(p)
*p = thechar;
} else {
strcpy(incfile, "/");
strcat(incfile, thestring);
strcat(incfile, "/include");
}
include[ninclude++] = incfile;
if(p = getenv("INCLUDE"))
include[ninclude-1] = p; /* */
of = mycreat(outfile, 0664);
if(of < 0) {
yyerror("%ca: cannot create %s", thechar, outfile);
errorexit();
}
Binit(&obuf, of, OWRITE);
pass = 1;
pinit(*argv);
for(i=0; i<nDlist; i++)
dodefine(Dlist[i]);
yyparse();
if(nerrors) {
cclean();
errorexit();
}
pass = 2;
outhist();
pinit(*argv);
for(i=0; i<nDlist; i++)
dodefine(Dlist[i]);
yyparse();
cclean();
if(nerrors)
errorexit();
exits(0);
}
/*
* Process a single external definition
*/
extdef()
{
register o;
int sclass, scflag;
struct nmlist typer;
register struct nmlist *ds;
if(((o=symbol())==EOFC) || o==SEMI)
return;
peeksym = o;
sclass = 0;
blklev = 0;
if (getkeywords(&sclass, &typer)==0) {
sclass = EXTERN;
if (peeksym!=NAME)
goto syntax;
}
scflag = 0;
if (sclass==DEFXTRN) {
scflag++;
sclass = EXTERN;
}
if (sclass!=EXTERN && sclass!=STATIC && sclass!=TYPEDEF)
error("Illegal storage class");
do {
defsym = 0;
paraml = NULL;
parame = NULL;
if (sclass==TYPEDEF) {
decl1(TYPEDEF, &typer, 0, (struct nmlist *)NULL);
continue;
}
decl1(EXTERN, &typer, 0, (struct nmlist *)NULL);
if ((ds=defsym)==0)
return;
funcsym = ds;
if ((ds->htype&XTYPE)==FUNC) {
if ((peeksym=symbol())==LBRACE || peeksym==KEYW
|| (peeksym==NAME && csym->hclass==TYPEDEF)) {
funcblk.type = decref(ds->htype);
funcblk.strp = ds->hstrp;
setinit(ds);
outcode("BS", SYMDEF, sclass==EXTERN?ds->name:"");
cfunc();
return;
}
if (paraml)
error("Inappropriate parameters");
} else if ((o=symbol())==COMMA || o==SEMI) {
peeksym = o;
o = (length((union tree *)ds)+ALIGN) & ~ALIGN;
if (sclass==STATIC) {
setinit(ds);
outcode("BSBBSBN", SYMDEF, "", BSS, NLABEL, ds->name, SSPACE, o);
} else if (scflag)
outcode("BSN", CSPACE, ds->name, o);
} else {
if (o!=ASSIGN) {
error("Declaration syntax");
peeksym = o;
}
setinit(ds);
if (sclass==EXTERN)
outcode("BS", SYMDEF, ds->name);
outcode("BBS", DATA, NLABEL, ds->name);
if (cinit(ds, 1, sclass) & ALIGN)
outcode("B", EVEN);
}
} while ((o=symbol())==COMMA);
if (o==SEMI)
return;
syntax:
if (o==RBRACE) {
error("Too many }'s");
peeksym = 0;
return;
}
error("External definition syntax");
errflush(o);
statement();
}
void
main(int argc, char *argv[])
{
char *p;
int c;
thechar = '8';
thestring = "386";
ctxt = linknew(&link386);
ctxt->diag = yyerror;
ctxt->bso = &bstdout;
Binit(&bstdout, 1, OWRITE);
listinit8();
fmtinstall('L', Lconv);
// Allow GOARCH=thestring or GOARCH=thestringsuffix,
// but not other values.
p = getgoarch();
if(strncmp(p, thestring, strlen(thestring)) != 0)
sysfatal("cannot use %cc with GOARCH=%s", thechar, p);
ensuresymb(NSYMB);
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
setinclude(".");
ARGBEGIN {
default:
c = ARGC();
if(c >= 0 && c < sizeof(debug))
debug[c] = 1;
break;
case 'o':
outfile = ARGF();
break;
case 'D':
p = ARGF();
if(p) {
if (nDlist%8 == 0)
Dlist = allocn(Dlist, nDlist*sizeof(char *),
8*sizeof(char *));
Dlist[nDlist++] = p;
}
break;
case 'I':
p = ARGF();
setinclude(p);
break;
case 'S':
ctxt->debugasm++;
break;
} ARGEND
if(*argv == 0) {
print("usage: %ca [-options] file.s\n", thechar);
errorexit();
}
if(argc > 1){
print("can't assemble multiple files\n");
errorexit();
}
if(assemble(argv[0]))
errorexit();
Bflush(&bstdout);
exits(0);
}
ssize_t
cread(int fd, void *buf, size_t nbytes, off_t offset)
{
Block *blk;
Block **pblk;
Block **ppblk;
int hi;
int n;
off_t mask;
/*
* If the cache is disabled, or we do not yet know the filesystem
* block size, then revert to pread. Otherwise initialize the
* cache as necessary and continue.
*/
if (cachesize <= 0 || sblock->fs_bsize == 0)
return(pread(fd, buf, nbytes, offset));
if (DataBase == NULL)
cinit();
/*
* If the request crosses a cache block boundary, or the
* request is larger or equal to the cache block size,
* revert to pread(). Full-block-reads are typically
* one-time calls and caching would be detrimental.
*/
mask = ~(off_t)(BlockSize - 1);
if (nbytes >= BlockSize ||
((offset ^ (offset + nbytes - 1)) & mask) != 0) {
return(pread(fd, buf, nbytes, offset));
}
/*
* Obtain and access the cache block. Cache a successful
* result. If an error occurs, revert to pread() (this might
* occur near the end of the media).
*/
hi = (offset / BlockSize) % HSize;
pblk = &BlockHash[hi];
ppblk = NULL;
while ((blk = *pblk) != NULL) {
if (((blk->b_Offset ^ offset) & mask) == 0)
break;
ppblk = pblk;
pblk = &blk->b_HNext;
}
if (blk == NULL) {
blk = *ppblk;
pblk = ppblk;
blk->b_Offset = offset & mask;
n = pread(fd, blk->b_Data, BlockSize, blk->b_Offset);
if (n != BlockSize) {
blk->b_Offset = (off_t)-1;
blk = NULL;
}
}
if (blk) {
bcopy(blk->b_Data + (offset - blk->b_Offset), buf, nbytes);
*pblk = blk->b_HNext;
blk->b_HNext = BlockHash[hi];
BlockHash[hi] = blk;
return(nbytes);
} else {
return(pread(fd, buf, nbytes, offset));
}
}
void
main(int argc, char *argv[])
{
char *p;
int nout, nproc, status, i, c;
thechar = '2';
thestring = "68020";
memset(debug, 0, sizeof(debug));
cinit();
outfile = 0;
include[ninclude++] = ".";
ARGBEGIN {
default:
c = ARGC();
if(c >= 0 || c < sizeof(debug))
debug[c] = 1;
break;
case 'o':
outfile = ARGF();
break;
case 'D':
p = ARGF();
if(p)
Dlist[nDlist++] = p;
break;
case 'I':
p = ARGF();
setinclude(p);
break;
} ARGEND
if(*argv == 0) {
print("usage: %ca [-options] file.s\n", thechar);
errorexit();
}
if(argc > 1 && systemtype(Windows)){
print("can't assemble multiple files on windows\n");
errorexit();
}
if(argc > 1 && !systemtype(Windows)) {
nproc = 1;
if(p = getenv("NPROC"))
nproc = atol(p); /* */
c = 0;
nout = 0;
for(;;) {
while(nout < nproc && argc > 0) {
i = myfork();
if(i < 0) {
i = mywait(&status);
if(i < 0)
errorexit();
if(status)
c++;
nout--;
continue;
}
if(i == 0) {
print("%s:\n", *argv);
if(assemble(*argv))
errorexit();
exits(0);
}
nout++;
argc--;
argv++;
}
i = mywait(&status);
if(i < 0) {
if(c)
errorexit();
exits(0);
}
if(status)
c++;
nout--;
}
}
if(assemble(argv[0]))
errorexit();
exits(0);
}
/*
* Initialization code.
* Called from cold start routine as
* soon as a stack and segmentation
* have been established.
* Functions:
* clear and free user core
* turn on clock
* hand craft 0th process
* call all initialization routines
* fork - process 0 to schedule
* - process 1 execute bootstrap
*/
int
main()
{
register struct proc *p;
register int i;
register struct fs *fs = NULL;
char inbuf[4];
char inch;
int s __attribute__((unused));
startup();
printf ("\n%s", version);
cpuidentify();
cnidentify();
/*
* Set up system process 0 (swapper).
*/
p = &proc[0];
p->p_addr = (size_t) &u;
p->p_stat = SRUN;
p->p_flag |= SLOAD | SSYS;
p->p_nice = NZERO;
u.u_procp = p; /* init user structure */
u.u_cmask = CMASK;
u.u_lastfile = -1;
for (i = 1; i < NGROUPS; i++)
u.u_groups[i] = NOGROUP;
for (i = 0; i < sizeof(u.u_rlimit)/sizeof(u.u_rlimit[0]); i++)
u.u_rlimit[i].rlim_cur = u.u_rlimit[i].rlim_max =
RLIM_INFINITY;
/* Initialize signal state for process 0 */
siginit (p);
/*
* Initialize tables, protocols, and set up well-known inodes.
*/
#ifdef LOG_ENABLED
loginit();
#endif
coutinit();
cinit();
pqinit();
ihinit();
bhinit();
binit();
nchinit();
clkstart();
s = spl0();
rdisk_init();
pipedev = rootdev = get_boot_device();
swapdev = get_swap_device();
/* Mount a root filesystem. */
for (;;) {
if(rootdev!=-1)
{
fs = mountfs (rootdev, (boothowto & RB_RDONLY) ? MNT_RDONLY : 0,
(struct inode*) 0);
}
if (fs)
break;
printf ("No root filesystem available!\n");
// rdisk_list_partitions(RDISK_FS);
retry:
printf ("Please enter device to boot from (press ? to list): ");
inch=0;
inbuf[0] = inbuf[1] = inbuf[2] = inbuf[3] = 0;
while((inch=cngetc()) != '\r')
{
switch(inch)
{
case '?':
printf("?\n");
rdisk_list_partitions(RDISK_FS);
printf ("Please enter device to boot from (press ? to list): ");
break;
default:
printf("%c",inch);
inbuf[0] = inbuf[1];
inbuf[1] = inbuf[2];
inbuf[2] = inbuf[3];
inbuf[3] = inch;
break;
}
}
inch = 0;
if(inbuf[0]=='r' && inbuf[1]=='d')
{
if(inbuf[2]>='0' && inbuf[2] < '0'+rdisk_num_disks())
{
if(inbuf[3]>='a' && inbuf[3]<='d')
{
rootdev=makedev(inbuf[2]-'0',inbuf[3]-'a'+1);
inch = 1;
}
}
} else if(inbuf[1]=='r' && inbuf[2]=='d') {
if(inbuf[3]>='0' && inbuf[3] < '0'+rdisk_num_disks())
{
rootdev=makedev(inbuf[3]-'0',0);
inch = 1;
}
} else if(inbuf[3] == 0) {
inch = 1;
}
if(inch==0)
{
printf("\nUnknown device.\n\n");
goto retry;
}
printf ("\n\n");
}
printf ("phys mem = %u kbytes\n", physmem / 1024);
printf ("user mem = %u kbytes\n", MAXMEM / 1024);
if(minor(rootdev)==0)
{
printf ("root dev = rd%d (%d,%d)\n",
major(rootdev),
major(rootdev), minor(rootdev)
);
} else {
printf ("root dev = rd%d%c (%d,%d)\n",
major(rootdev), 'a'+minor(rootdev)-1,
major(rootdev), minor(rootdev)
);
}
printf ("root size = %u kbytes\n", fs->fs_fsize * DEV_BSIZE / 1024);
mount[0].m_inodp = (struct inode*) 1; /* XXX */
mount_updname (fs, "/", "root", 1, 4);
time.tv_sec = fs->fs_time;
boottime = time;
/* Find a swap file. */
swapstart = 1;
while(swapdev == -1)
{
printf("Please enter swap device (press ? to list): ");
inbuf[0] = inbuf[1] = inbuf[2] = inbuf[3] = 0;
while((inch = cngetc())!='\r')
{
switch(inch)
{
case '?':
printf("?\n");
rdisk_list_partitions(RDISK_SWAP);
printf("Please enter swap device (press ? to list): ");
break;
default:
printf("%c",inch);
inbuf[0] = inbuf[1];
inbuf[1] = inbuf[2];
inbuf[2] = inbuf[3];
inbuf[3] = inch;
break;
}
}
inch = 0;
if(inbuf[0]=='r' && inbuf[1]=='d')
{
if(inbuf[2]>='0' && inbuf[2] < '0'+rdisk_num_disks())
{
if(inbuf[3]>='a' && inbuf[3]<='d')
{
swapdev=makedev(inbuf[2]-'0',inbuf[3]-'a'+1);
inch = 1;
}
}
} else if(inbuf[1]=='r' && inbuf[2]=='d') {
if(inbuf[3]>='0' && inbuf[3] < '0'+rdisk_num_disks())
{
swapdev=makedev(inbuf[3]-'0',0);
inch = 1;
}
}
if(minor(swapdev)!=0)
{
if(partition_type(swapdev)!=RDISK_SWAP)
{
printf("\nNot a swap partition!\n\n");
swapdev=-1;
}
}
}
nswap = rdsize(swapdev);
if(minor(swapdev)==0)
{
printf ("swap dev = rd%d (%d,%d)\n",
major(swapdev),
major(swapdev), minor(swapdev)
);
} else {
printf ("swap dev = rd%d%c (%d,%d)\n",
major(swapdev), 'a'+minor(swapdev)-1,
major(swapdev), minor(swapdev)
);
}
(*bdevsw[major(swapdev)].d_open)(swapdev, FREAD|FWRITE, S_IFBLK);
printf ("swap size = %u kbytes\n", nswap * DEV_BSIZE / 1024);
if (nswap <= 0)
panic ("zero swap size"); /* don't want to panic, but what ? */
mfree (swapmap, nswap, swapstart);
/* Kick off timeout driven events by calling first time. */
schedcpu (0);
/* Set up the root file system. */
rootdir = iget (rootdev, &mount[0].m_filsys, (ino_t) ROOTINO);
iunlock (rootdir);
u.u_cdir = iget (rootdev, &mount[0].m_filsys, (ino_t) ROOTINO);
iunlock (u.u_cdir);
u.u_rdir = NULL;
/*
* Make init process.
*/
if (newproc (0) == 0) {
/* Parent process with pid 0: swapper.
* No return from sched. */
sched();
}
/* Child process with pid 1: init. */
s = splhigh();
p = u.u_procp;
p->p_dsize = icodeend - icode;
p->p_daddr = USER_DATA_START;
p->p_ssize = 1024; /* one kbyte of stack */
p->p_saddr = USER_DATA_END - 1024;
bcopy ((caddr_t) icode, (caddr_t) USER_DATA_START, icodeend - icode);
/*
* return goes to location 0 of user init code
* just copied out.
*/
return 0;
}