static void
ob_sd_open(ATTRIBUTE_UNUSEDsd_private_t **sd)
{
int ret = 1, id;
phandle_t ph;
fword("my-unit");
id = POP();
POP(); // unit id is 2 ints but we only need one.
*sd = &global_esp->sd[id];
#ifdef CONFIG_DEBUG_ESP
{
char *args;
fword("my-args");
args = pop_fstr_copy();
DPRINTF("opening drive %d args %s\n", id, args);
free(args);
}
#endif
selfword("open-deblocker");
/* interpose disk-label */
ph = find_dev("/packages/disk-label");
fword("my-args");
PUSH_ph( ph );
fword("interpose");
RET ( -ret );
}
/* ( -- success? ) */
static void
scsi_open( instance_data_t *sd )
{
static int once = 0;
phandle_t ph;
fword("my-unit");
sd->target = POP();
if( !once ) {
once++;
OSI_SCSIControl( SCSI_CTRL_INIT, 0 );
}
/* obtiain device information */
if( inquiry(sd) )
RET(0);
selfword("open-deblocker");
/* interpose disk-label */
ph = find_dev("/packages/disk-label");
fword("my-args");
PUSH_ph( ph );
fword("interpose");
PUSH( -1 );
}
void init_forth_context(void)
{
/* Execute Forth payload */
printk("Evaluating Forth...\n");
fword("load-base");
feval("load-state >ls.file-size @");
fword("eval2");
}
void init_fcode_context(void)
{
/* Execute FCode payload */
printk("Evaluating FCode...\n");
fword("load-base");
PUSH(1);
fword("byte-load");
}
void
ob_init_iommu(uint64_t base)
{
struct iommu_regs *regs;
regs = iommu_init(&ciommu, base);
push_str("/iommu");
fword("find-device");
PUSH((unsigned long)regs);
fword("encode-int");
push_str("address");
fword("property");
PUSH(base >> 32);
fword("encode-int");
PUSH(base & 0xffffffff);
fword("encode-int");
fword("encode+");
PUSH(IOMMU_REGS);
fword("encode-int");
fword("encode+");
push_str("reg");
fword("property");
bind_func("map-in", ob_iommu_map_in);
bind_func("map-out", ob_iommu_map_out);
}
static void
add_alias(const char *device, const char *alias)
{
DPRINTF("add_alias dev \"%s\" = alias \"%s\"\n", device, alias);
push_str("/aliases");
fword("find-device");
push_str(device);
fword("encode-string");
push_str(alias);
fword("property");
}
void go(void)
{
ucell address, type, size;
int image_retval = 0;
/* Get the entry point and the type (see forth/debugging/client.fs) */
feval("saved-program-state >sps.entry @");
address = POP();
feval("saved-program-state >sps.file-type @");
type = POP();
feval("saved-program-state >sps.file-size @");
size = POP();
printk("\nJumping to entry point " FMT_ucellx " for type " FMT_ucellx "...\n", address, type);
switch (type) {
case 0x0:
/* Start ELF boot image */
image_retval = start_elf(address, (uint32_t)&elf_boot_notes);
break;
case 0x1:
/* Start ELF image */
image_retval = start_elf(address, (uint32_t)NULL);
break;
case 0x5:
/* Start a.out image */
image_retval = start_elf(address, (uint32_t)NULL);
break;
case 0x10:
/* Start Fcode image */
printk("Evaluating FCode...\n");
PUSH(address);
PUSH(1);
fword("byte-load");
image_retval = 0;
break;
case 0x11:
/* Start Forth image */
PUSH(address);
PUSH(size);
fword("eval2");
image_retval = 0;
break;
}
printk("Image returned with return value %#x\n", image_retval);
}
static void
setenv( char *env, char *value )
{
push_str( value );
push_str( env );
fword("$setenv");
}
void
bind_func( const char *name, void (*func)(void) )
{
PUSH( pointer2cell(func) );
push_str( name );
fword("is-cfunc");
}
xt_t
bind_noname_func( void (*func)(void) )
{
PUSH( pointer2cell(func) );
fword("is-noname-cfunc");
return POP_xt();
}
void
update_nvram( void )
{
PUSH( pointer2cell(nvram.config->data) );
PUSH( nvram.config_size );
fword("nvram-store-configs");
arch_nvram_put( nvram.data );
}
void
nvconf_init( void )
{
int once=0;
/* initialize nvram structure completely */
nvram.config = NULL;
nvram.config_size = 0;
nvram.size = arch_nvram_size();
nvram.data = malloc( nvram.size );
arch_nvram_get( nvram.data );
bind_func( "update-nvram", update_nvram );
for( ;; ) {
nvpart_t *p = NULL;
int err;
while( (err=next_nvpart(&p)) > 0 ) {
if( nvpart_checksum(p) != p->checksum ) {
err = -1;
break;
}
if( p->signature == NV_SIG_SYSTEM ) {
nvram.config = p;
nvram.config_size = nvpart_size(p) - 0x10;
if( !once++ ) {
PUSH( pointer2cell(p->data) );
PUSH( nvram.config_size );
fword("nvram-load-configs");
}
}
}
if( err || !nvram.config ) {
printk("nvram error detected, zapping pram\n");
zap_nvram();
if( !once++ )
fword("set-defaults");
continue;
}
break;
}
}
static void
ob_esp_initialize(ATTRIBUTE_UNUSED esp_private_t **esp)
{
phandle_t ph = get_cur_dev();
set_int_property(ph, "#address-cells", 2);
set_int_property(ph, "#size-cells", 0);
/* set device type */
push_str("scsi");
fword("device-type");
/* QEMU's ESP emulation does not support mixing DMA and FIFO messages. By
setting this attribute, we prevent the Solaris ESP kernel driver from
trying to use this feature when booting a disk image (and failing) */
PUSH(0x58);
fword("encode-int");
push_str("scsi-options");
fword("property");
PUSH(0x24);
fword("encode-int");
PUSH(0);
fword("encode-int");
fword("encode+");
push_str("intr");
fword("property");
}
void
bind_xtfunc( const char *name, xt_t xt, ucell arg, void (*func)(void) )
{
PUSH_xt( xt );
PUSH( arg );
PUSH( pointer2cell(func) );
push_str( name );
fword("is-xt-cfunc");
}
int
bootcode_load(ihandle_t dev)
{
int retval = -1, count = 0, fd;
unsigned long bootcode, loadbase, offset;
/* Mark the saved-program-state as invalid */
feval("0 state-valid !");
fd = open_ih(dev);
if (fd == -1) {
goto out;
}
/* Default to loading at load-base */
fword("load-base");
loadbase = POP();
#ifdef CONFIG_PPC
/* However Old World Macs need to load to a different address */
if (is_oldworld()) {
loadbase = OLDWORLD_BOOTCODE_BASEADDR;
}
#endif
bootcode = loadbase;
offset = 0;
while(1) {
if (seek_io(fd, offset) == -1)
break;
count = read_io(fd, (void *)bootcode, 512);
offset += count;
bootcode += count;
}
/* If we didn't read anything then exit */
if (!count) {
goto out;
}
/* Initialise saved-program-state */
PUSH(loadbase);
feval("saved-program-state >sps.entry !");
PUSH(offset);
feval("saved-program-state >sps.file-size !");
feval("bootcode saved-program-state >sps.file-type !");
feval("-1 state-valid !");
out:
close_io(fd);
return retval;
}
int openbios(void)
{
#ifdef CONFIG_DEBUG_CONSOLE
#ifdef CONFIG_DEBUG_CONSOLE_SERIAL
uart_init(CONFIG_SERIAL_PORT, CONFIG_SERIAL_SPEED);
#endif
/* Clear the screen. */
cls();
#endif
collect_sys_info(&sys_info);
dict = (unsigned char *)sys_info.dict_start;
dicthead = (cell)sys_info.dict_end;
last = sys_info.dict_last;
dictlimit = sys_info.dict_limit;
forth_init();
relocate(&sys_info);
#ifdef CONFIG_DEBUG_CONSOLE_VGA
video_init();
#endif
#ifdef CONFIG_DEBUG_BOOT
printk("forth started.\n");
printk("initializing memory...");
#endif
init_memory();
#ifdef CONFIG_DEBUG_BOOT
printk("done\n");
#endif
PUSH_xt( bind_noname_func(arch_init) );
fword("PREPOST-initializer");
PC = (ucell)findword("initialize-of");
if (!PC) {
printk("panic: no dictionary entry point.\n");
return -1;
}
#ifdef CONFIG_DEBUG_DICTIONARY
printk("done (%d bytes).\n", dicthead);
printk("Jumping to dictionary...\n");
#endif
enterforth((xt_t)PC);
return 0;
}
void
boot( void )
{
uint16_t boot_device = fw_cfg_read_i16(FW_CFG_BOOT_DEVICE);
fword("update-chosen");
if (boot_device == 'm') {
check_preloaded_kernel();
}
if (is_apple()) {
update_nvram();
}
}
static void
ob_cuda_initialize (int *idx)
{
phandle_t ph=get_cur_dev();
int props[2];
push_str("via-cuda");
fword("device-type");
set_int_property(ph, "#address-cells", 1);
set_int_property(ph, "#size-cells", 0);
set_property(ph, "compatible", "cuda", 5);
props[0] = __cpu_to_be32(IO_CUDA_OFFSET);
props[1] = __cpu_to_be32(IO_CUDA_SIZE);
set_property(ph, "reg", (char *)&props, sizeof(props));
/* on newworld machines the cuda is on interrupt 0x19 */
props[0] = 0x19;
props[1] = 0;
NEWWORLD(set_property(ph, "interrupts", (char *)props, sizeof(props)));
NEWWORLD(set_int_property(ph, "#interrupt-cells", 2));
/* we emulate an oldworld hardware, so we must use
* non-standard oldworld property (needed by linux 2.6.18)
*/
OLDWORLD(set_int_property(ph, "AAPL,interrupts", 0x12));
bind_func("ppc32-reset-all", ppc32_reset_all);
push_str("' ppc32-reset-all to reset-all");
fword("eval");
}
void boot(void)
{
char *path, *param;
/* Copy the incoming path */
fword("2dup");
path = pop_fstr_copy();
/* Boot preloaded kernel */
if (kernel_size) {
void (*entry)(unsigned long p1, unsigned long p2, unsigned long p3,
unsigned long p4, unsigned long p5);
printk("[sparc64] Kernel already loaded\n");
entry = (void *) (unsigned long)kernel_image;
entry(0, 0, 0, 0, (unsigned long)&sparc64_of_client_interface);
}
/* Invoke Linux directly -- probably not supported */
if(!path) {
/* No path specified, so grab defaults from /chosen */
push_str("bootpath");
push_str("/chosen");
fword("(find-dev)");
POP();
fword("get-package-property");
POP();
/* Update our local copy of path as well as the one on the stack */
fword("2dup");
path = pop_fstr_copy();
}
if (path) {
param = strchr(path, ' ');
if(param) {
*param = '\0';
param++;
} else if (cmdline_size) {
param = (char *)qemu_cmdline;
} else {
push_str("boot-args");
push_str("/options");
fword("(find-dev)");
POP();
fword("get-package-property");
POP();
param = pop_fstr_copy();
}
/* Invoke platform-specific Linux loader */
linux_load(&sys_info, path, param);
free(path);
}
}
static void
ofmem_set_property( phandle_t ph, const char *name, const char *buf, int len )
{
/* This is very similar to set_property() in libopenbios/bindings.c but allows
us to set the property pointer directly, rather than having to copy it
into the Forth dictonary every time we update the memory properties */
if( !ph ) {
printk("ofmem_set_property: NULL phandle\n");
return;
}
PUSH(pointer2cell(buf));
PUSH(len);
push_str(name);
PUSH_ph(ph);
fword("encode-property");
}
void Dictionary::printall(){
uint wit = 0;
for(std::vector<Wordinfo>::iterator _wit = fwa.begin(); _wit < fwa.end(); _wit ++){
for(std::map<uint,uint>::iterator pit = fwa[wit].pairs.begin(); pit != fwa[wit].pairs.end(); pit++){
Word fword(french,wit);
Word eword(english,(*pit).first);
std::cout << fwa[fword].relFreq(eword);
std::cout << " " << ewa[eword].relFreq(fword);
//std::cout << "@" << fwa[fword].pairs[(*pit).first] << "/" << fwa[fword].singlecount;
//std::cout << "@" << ewa[eword].pairs[(*pit).first] << "/" << ewa[eword].singlecount;
std::cout << " # " << flex.getString(fword) << " # ";
std::cout << elex.getString(eword) << "\n";
}
wit++;
}
}
void
arch_of_init( void )
{
#if USE_RTAS
phandle_t ph;
#endif
int autoboot;
devtree_init();
node_methods_init();
modules_init();
setup_timers();
#ifdef CONFIG_DRIVER_PCI
ob_pci_init();
#endif
#if USE_RTAS
if( !(ph=find_dev("/rtas")) )
printk("Warning: No /rtas node\n");
else {
ulong size = 0x1000;
while( size < (ulong)of_rtas_end - (ulong)of_rtas_start )
size *= 2;
set_property( ph, "rtas-size", (char*)&size, sizeof(size) );
}
#endif
#if 0
/* tweak boot settings */
autoboot = !!get_bool_res("autoboot");
#endif
autoboot = 0;
if( !autoboot )
printk("Autobooting disabled - dropping into OpenFirmware\n");
setenv("auto-boot?", autoboot ? "true" : "false" );
setenv("boot-command", "briqboot");
#if 0
if( get_bool_res("tty-interface") == 1 )
#endif
fword("activate-tty-interface");
/* hack */
device_end();
bind_func("briqboot", boot );
}
int forth_load(const char *filename)
{
char magic[2];
unsigned long forthsize;
int retval = -1;
if (!file_open(filename))
goto out;
if (lfile_read(magic, 2) != 2) {
debug("Can't read magic header\n");
retval = LOADER_NOT_SUPPORT;
goto out;
}
if (magic[0] != '\\' || magic[1] != ' ') {
debug("No forth source image\n");
retval = LOADER_NOT_SUPPORT;
goto out;
}
forthsize = file_size();
forthtext = malloc(forthsize+1);
file_seek(0);
printk("Loading forth source ...");
if ((unsigned long)lfile_read(forthtext, forthsize) != forthsize) {
printk("Can't read forth text\n");
goto out;
}
forthtext[forthsize]=0;
printk("ok\n");
PUSH ( (ucell)forthtext );
PUSH ( (ucell)forthsize );
fword("eval2");
retval=0;
out:
//if (forthtext)
// free(forthtext);
return retval;
}
void
boot( void )
{
char *path;
void *entry;
/* Copy the incoming path */
fword("2dup");
path = pop_fstr_copy();
if(!path) {
printk("[unix] Booting default not supported.\n");
return;
}
printk("[unix] Booting '%s'\n",path);
entry=load_elf(path);
if(entry)
printk("successfully loaded client at %llx.\n", (unsigned long long)(ucell)entry);
else
printk("failed.\n");
}
void
aout_init_program(void)
{
ucell start, size;
// Relocate a.out text down from load-base to load-base - header. This
// is similar to what OBP does and is needed for NextStep.
fword("load-base");
start = POP();
feval("load-state >ls.file-size @");
size = POP();
memmove((char *)start - sizeof(struct exec), (char *)start, size);
PUSH(start);
feval("load-state >ls.entry !");
arch_init_program();
feval("-1 state-valid !");
}
void
arch_of_init( void )
{
mol_phandle_t ph;
int autoboot;
devtree_init();
node_methods_init();
nvram_init("/pci/mac-io/nvram");
openbios_init();
modules_init();
pseudodisk_init();
osiblk_init();
osiscsi_init();
init_video();
if( (ph=prom_find_device("/rtas")) == -1 )
printk("Warning: No /rtas node\n");
else {
unsigned long size = 0x1000;
while( size < (unsigned long)of_rtas_end - (unsigned long)of_rtas_start )
size *= 2;
prom_set_prop( ph, "rtas-size", (char*)&size, sizeof(size) );
}
/* tweak boot settings */
autoboot = !!get_bool_res("autoboot");
if( !autoboot )
printk("Autobooting disabled - dropping into OpenFirmware\n");
setenv("auto-boot?", autoboot ? "true" : "false" );
setenv("boot-command", "molboot");
if( get_bool_res("tty-interface") == 1 )
fword("activate-tty-interface");
/* hack */
device_end();
bind_func("molboot", boot );
}
/*
* v_wordw -- [count]w
* Move forward a word at a time.
*
* PUBLIC: int v_wordw __P((SCR *, VICMD *));
*/
int
v_wordw(SCR *sp, VICMD *vp)
{
return (fword(sp, vp, LITTLEWORD));
}
/*
* v_wordW -- [count]W
* Move forward a bigword at a time.
*
* PUBLIC: int v_wordW __P((SCR *, VICMD *));
*/
int
v_wordW(SCR *sp, VICMD *vp)
{
return (fword(sp, vp, BIGWORD));
}
/* ( open -- flag ) */
static void
macparts_open( macparts_info_t *di )
{
char *str = my_args_copy();
char *parstr = NULL, *argstr = NULL;
char *tmpstr;
int bs, parnum=-1, apple_parnum=-1;
int parlist[2], parlist_size = 0;
desc_map_t dmap;
part_entry_t par;
int ret = 0, i = 0, j = 0;
int want_bootcode = 0;
phandle_t ph;
ducell offs = 0, size = -1;
DPRINTF("macparts_open '%s'\n", str );
/*
Arguments that we accept:
id: [0-7]
[(id)][,][filespec]
*/
if ( str && strlen(str) ) {
/* Detect the arguments */
if ((*str >= '0' && *str <= '9') || (*str == ',')) {
push_str(str);
PUSH(',');
fword("left-parse-string");
parstr = pop_fstr_copy();
argstr = pop_fstr_copy();
} else {
argstr = str;
}
/* Make sure argstr is not null */
if (argstr == NULL)
argstr = strdup("");
/* Convert the id to a partition number */
if (parstr && strlen(parstr))
parnum = atol(parstr);
/* Detect if we are looking for the bootcode */
if (strcmp(argstr, "%BOOT") == 0) {
want_bootcode = 1;
}
}
DPRINTF("parstr: %s argstr: %s parnum: %d\n", parstr, argstr, parnum);
DPRINTF("want_bootcode %d\n", want_bootcode);
DPRINTF("macparts_open %d\n", parnum);
di->filesystem_ph = 0;
di->read_xt = find_parent_method("read");
di->seek_xt = find_parent_method("seek");
SEEK( 0 );
if( READ(&dmap, sizeof(dmap)) != sizeof(dmap) )
goto out;
/* partition maps might support multiple block sizes; in this case,
* pmPyPartStart is typically given in terms of 512 byte blocks.
*/
bs = __be16_to_cpu(dmap.sbBlockSize);
if( bs != 512 ) {
SEEK( 512 );
READ( &par, sizeof(par) );
if( __be16_to_cpu(par.pmSig) == DESC_PART_SIGNATURE )
bs = 512;
}
SEEK( bs );
if( READ(&par, sizeof(par)) != sizeof(par) )
goto out;
if (__be16_to_cpu(par.pmSig) != DESC_PART_SIGNATURE)
goto out;
/*
* Implement partition selection as per the PowerPC Microprocessor CHRP bindings
*/
if (argstr == NULL || parnum == 0) {
/* According to the spec, partition 0 as well as no arguments means the whole disk */
offs = (long long)0;
size = (long long)__be32_to_cpu(dmap.sbBlkCount) * bs;
di->blocksize = (unsigned int)bs;
di->offs_hi = offs >> BITS;
di->offs_lo = offs & (ucell) -1;
di->size_hi = size >> BITS;
di->size_lo = size & (ucell) -1;
ret = -1;
goto out;
} else if (parnum == -1) {
int main (int argc, char* argv[]) {
BogglePlayer * p = new BogglePlayer();
//test getAllValid
set<string> lex;
string line;
std::ifstream fword("boglex.txt",ios::binary);
while(fword.good()){
std::getline(fword,line);
lex.insert(line);
}
fword.close();
p->buildLexicon(lex);
// std::ifstream f("brd.txt",ios::binary);
// // int row=0;
// // int col=0;
// std::getline(f,line);
// //row=std::stoi(line);
// std::getline(f,line);
// //col=std::stoi(line);
// string brd[20][23];
// for(int i=0;i<20;i++){
// for(int j=0;j<23;j++){
// std::getline(f,line);
// brd[i][j]=line;
// }
// }
// f.close();
// string* bd[20];
// for(int i=0;i<20;i++){
// bd[i]=brd[i];
// }
// p->setBoard(20,23,bd);
// for(int i=0;i<20;i++){
// for(int j=0;j<23;j++){
// cout << p->board[i*23+j].letter<<" ";
// }
// cout<<endl;
// }
// std::vector<int> v;
// v= p->isOnBoard("acidified");
// for(int i=0;i<v.size();i++){
// cout<<v[i]<<endl;
// }
//cout << "size " << p->isOnBoard("acidified").size() <<endl;
// string wordA("a");
// string wordX("x");
// lex.insert(wordA);
// lex.insert("aba");
string row0[] = {"w"};
string row1[] = {"e"};
string row2[] = {"r"};
string row3[] = {"e"};
string* board[] = {row0,row1,row2,row3};
set<string> words;
// vector<int> locations;
//p->buildLexicon(lex);
//cout << "build" << endl;
p->setBoard(4,1,board);
// // for(int i=0;i<4;i++){
// // cout << p->board[i].letter << endl;
// // }
// if(p->isOnBoard("aba").size() == 3){
// cout << "found" << endl;
// }
// if(p->isInLexicon(wordX)) {
// std::cerr << "Apparent problem with isInLexicon #1." << std::endl;
// return -1;
// }
// if(!p->isInLexicon(wordA)) {
// std::cerr << "Apparent problem with isInLexicon #2." << std::endl;
// return -1;
// }
// if(p->isOnBoard(wordA).size() != 1) {
// std::cerr << "Apparent problem with isOnBoard #1." << std::endl;
// return -1;
// }
// locations.clear();
// locations = p->isOnBoard(wordA);
// if(locations.size() != 1 || locations[0] != 3) {
// std::cerr << "Apparent problem with isOnBoard #2." << std::endl;
// return -1;
// }
// if(!p->getAllValidWords(0,&words)) {
// std::cerr << "Apparent problem with getAllValidWords #1." << std::endl;
// return -1;
// }
// if(words.size() != 1 || words.count(wordA) != 1) {
// std::cerr << "Apparent problem with getAllValidWords #2." << std::endl;
// return -1;
// }
//set<string> words;
p->getAllValidWords(0,&words);
int j=0;
for (std::set<string>::iterator it = words.begin() ; it != words.end(); ++it){
j++;
cout<<j<< " valid words "<<*it<<endl;
}
cout<<"total number"<<words.size()<<endl;
delete p;
return 0;
}
