/**
* We've already built the sentence disjuncts, and we've pruned them
* and power_pruned(GENTLE) them also. The sentence contains a
* conjunction. deletable[][] has been initialized to indicate the
* ranges which may be deleted in the final linkage.
*
* This routine deletes irrelevant disjuncts. It finds them by first
* marking them all as irrelevant, and then marking the ones that
* might be useable. Finally, the unmarked ones are removed.
*/
void conjunction_prune(Sentence sent, Parse_Options opts)
{
Disjunct * d;
int w;
count_context_t *ctxt = sent->count_ctxt;
ctxt->current_resources = opts->resources;
ctxt->deletable = sent->deletable;
count_set_effective_distance(sent);
/* We begin by unmarking all disjuncts. This would not be necessary if
whenever we created a disjunct we cleared its marked field.
I didn't want to search the program for all such places, so
I did this way. XXX FIXME, someday ...
*/
for (w=0; w<sent->length; w++) {
for (d=sent->word[w].d; d != NULL; d=d->next) {
d->marked = FALSE;
}
}
init_fast_matcher(sent);
ctxt->local_sent = sent->word;
ctxt->null_links = (opts->min_null_count > 0);
/*
for (d = sent->word[0].d; d != NULL; d = d->next) {
if ((d->left == NULL) && region_valid(sent, 0, sent->length, d->right, NULL)) {
mark_region(sent, 0, sent->length, d->right, NULL);
d->marked = TRUE;
}
}
mark_region(sent, 0, sent->length, NULL, NULL);
*/
if (ctxt->null_links) {
mark_region(sent, -1, sent->length, NULL, NULL);
} else {
for (w=0; w<sent->length; w++) {
/* consider removing the words [0,w-1] from the beginning
of the sentence */
if (ctxt->deletable[-1][w]) {
for (d = sent->word[w].d; d != NULL; d = d->next) {
if ((d->left == NULL) && region_valid(sent, w, sent->length, d->right, NULL)) {
mark_region(sent, w, sent->length, d->right, NULL);
d->marked = TRUE;
}
}
}
}
}
delete_unmarked_disjuncts(sent);
free_fast_matcher(sent);
ctxt->local_sent = NULL;
ctxt->current_resources = NULL;
ctxt->deletable = NULL;
count_unset_effective_distance(sent);
}
static int __init zorro_init(void)
{
struct zorro_dev *z;
unsigned int i;
if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
return 0;
pr_info("Zorro: Probing AutoConfig expansion devices: %d device%s\n",
zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
/* Initialize the Zorro bus */
INIT_LIST_HEAD(&zorro_bus.devices);
strcpy(zorro_bus.dev.bus_id, "zorro");
device_register(&zorro_bus.dev);
/* Request the resources */
zorro_bus.num_resources = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
for (i = 0; i < zorro_bus.num_resources; i++)
request_resource(&iomem_resource, &zorro_bus.resources[i]);
/* Register all devices */
for (i = 0; i < zorro_num_autocon; i++) {
z = &zorro_autocon[i];
z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8);
if (z->id == ZORRO_PROD_GVP_EPC_BASE) {
/* GVP quirk */
unsigned long magic = zorro_resource_start(z)+0x8000;
z->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK;
}
sprintf(z->name, "Zorro device %08x", z->id);
zorro_name_device(z);
z->resource.name = z->name;
if (request_resource(zorro_find_parent_resource(z), &z->resource))
printk(KERN_ERR "Zorro: Address space collision on device %s "
"[%lx:%lx]\n",
z->name, (unsigned long)zorro_resource_start(z),
(unsigned long)zorro_resource_end(z));
sprintf(z->dev.bus_id, "%02x", i);
z->dev.parent = &zorro_bus.dev;
z->dev.bus = &zorro_bus_type;
device_register(&z->dev);
zorro_create_sysfs_dev_files(z);
}
/* Mark all available Zorro II memory */
zorro_for_each_dev(z) {
if (z->rom.er_Type & ERTF_MEMLIST)
mark_region(zorro_resource_start(z), zorro_resource_end(z)+1, 1);
}
/* Unmark all used Zorro II memory */
for (i = 0; i < m68k_num_memory; i++)
if (m68k_memory[i].addr < 16*1024*1024)
mark_region(m68k_memory[i].addr,
m68k_memory[i].addr+m68k_memory[i].size, 0);
return 0;
}
void __init zorro_init(void)
{
struct zorro_dev *dev;
u_int i;
if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
return;
printk("Zorro: Probing AutoConfig expansion devices: %d device%s\n",
zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
/* Request the resources */
zorro_num_res = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
for (i = 0; i < zorro_num_res; i++)
request_resource(&iomem_resource, &zorro_res[i]);
for (i = 0; i < zorro_num_autocon; i++) {
dev = &zorro_autocon[i];
dev->id = (dev->rom.er_Manufacturer<<16) | (dev->rom.er_Product<<8);
if (dev->id == ZORRO_PROD_GVP_EPC_BASE) {
/* GVP quirk */
unsigned long magic = dev->resource.start+0x8000;
dev->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK;
}
sprintf(dev->name, "Zorro device %08x", dev->id);
zorro_name_device(dev);
dev->resource.name = dev->name;
if (request_resource(zorro_find_parent_resource(dev), &dev->resource))
printk(KERN_ERR "Zorro: Address space collision on device %s "
"[%lx:%lx]\n",
dev->name, dev->resource.start, dev->resource.end);
}
/* Mark all available Zorro II memory */
for (i = 0; i < zorro_num_autocon; i++) {
dev = &zorro_autocon[i];
if (dev->rom.er_Type & ERTF_MEMLIST)
mark_region(dev->resource.start, dev->resource.end+1, 1);
}
/* Unmark all used Zorro II memory */
for (i = 0; i < m68k_num_memory; i++)
if (m68k_memory[i].addr < 16*1024*1024)
mark_region(m68k_memory[i].addr,
m68k_memory[i].addr+m68k_memory[i].size, 0);
}
void arch_do_mboot(struct multiboot *m)
{
/* parse mmap but first let me take a selfie with paging */
init_paging(m->mem_upper + m->mem_lower);
if (m->flags & (1 << 6)) {
printk("x86: multiboot: parsing memory map...\n");
mboot_memmap_t *mmap = (void *)m->mmap_addr;
while((uintptr_t)mmap < m->mmap_addr + m->mmap_length) {
if (mmap->type == 2) {
for (uint64_t i = 0; i < mmap->length; i += 0x1000) {
if (mmap->base_addr + i > 0xFFFFFFFF);
mark_region((mmap->base_addr + i) & 0xFFFFF000);
}
}
mmap = (mboot_memmap_t *) ((uintptr_t)mmap + mmap->size + sizeof(uintptr_t));
}
}
printk("x86: multiboot: parse complete\n");
}
static int __init amiga_zorro_probe(struct platform_device *pdev)
{
struct zorro_bus *bus;
struct zorro_dev *z;
struct resource *r;
unsigned int i;
int error;
/* Initialize the Zorro bus */
bus = kzalloc(sizeof(*bus), GFP_KERNEL);
if (!bus)
return -ENOMEM;
INIT_LIST_HEAD(&bus->devices);
bus->dev.parent = &pdev->dev;
dev_set_name(&bus->dev, "zorro");
error = device_register(&bus->dev);
if (error) {
pr_err("Zorro: Error registering zorro_bus\n");
kfree(bus);
return error;
}
platform_set_drvdata(pdev, bus);
/* Register all devices */
pr_info("Zorro: Probing AutoConfig expansion devices: %u device%s\n",
zorro_num_autocon, zorro_num_autocon == 1 ? "" : "s");
for (i = 0; i < zorro_num_autocon; i++) {
z = &zorro_autocon[i];
z->id = (z->rom.er_Manufacturer<<16) | (z->rom.er_Product<<8);
if (z->id == ZORRO_PROD_GVP_EPC_BASE) {
/* GVP quirk */
unsigned long magic = zorro_resource_start(z)+0x8000;
z->id |= *(u16 *)ZTWO_VADDR(magic) & GVP_PRODMASK;
}
sprintf(z->name, "Zorro device %08x", z->id);
zorro_name_device(z);
z->resource.name = z->name;
r = zorro_find_parent_resource(pdev, z);
error = request_resource(r, &z->resource);
if (error)
dev_err(&bus->dev,
"Address space collision on device %s %pR\n",
z->name, &z->resource);
dev_set_name(&z->dev, "%02x", i);
z->dev.parent = &bus->dev;
z->dev.bus = &zorro_bus_type;
error = device_register(&z->dev);
if (error) {
dev_err(&bus->dev, "Error registering device %s\n",
z->name);
continue;
}
error = zorro_create_sysfs_dev_files(z);
if (error)
dev_err(&z->dev, "Error creating sysfs files\n");
}
/* Mark all available Zorro II memory */
zorro_for_each_dev(z) {
if (z->rom.er_Type & ERTF_MEMLIST)
mark_region(zorro_resource_start(z),
zorro_resource_end(z)+1, 1);
}
/* Unmark all used Zorro II memory */
for (i = 0; i < m68k_num_memory; i++)
if (m68k_memory[i].addr < 16*1024*1024)
mark_region(m68k_memory[i].addr,
m68k_memory[i].addr+m68k_memory[i].size,
0);
return 0;
}
/**
* Mark as useful all disjuncts involved in some way to complete the
* structure within the current region. Note that only disjuncts
* strictly between lw and rw will be marked. If it so happens that
* this region itself is not valid, then this fact will be recorded
* in the table, and nothing else happens.
*/
static void mark_region(Sentence sent,
int lw, int rw, Connector *le, Connector *re)
{
Disjunct * d;
int left_valid, right_valid, i;
int start_word, end_word;
int w;
Match_node * m, *m1;
count_context_t *ctxt = sent->count_ctxt;
i = region_valid(sent, lw, rw, le, re);
if ((i==0) || (i==2)) return;
/* we only reach this point if it's a valid unmarked region, i=1 */
table_update(ctxt, lw, rw, le, re, 0, 2);
if ((le == NULL) && (re == NULL) && (ctxt->null_links) && (rw != 1+lw)) {
w = lw+1;
for (d = ctxt->local_sent[w].d; d != NULL; d = d->next) {
if ((d->left == NULL) && region_valid(sent, w, rw, d->right, NULL)) {
d->marked = TRUE;
mark_region(sent, w, rw, d->right, NULL);
}
}
mark_region(sent, w, rw, NULL, NULL);
return;
}
if (le == NULL) {
start_word = lw+1;
} else {
start_word = le->word;
}
if (re == NULL) {
end_word = rw-1;
} else {
end_word = re->word;
}
for (w=start_word; w < end_word+1; w++) {
m1 = m = form_match_list(sent, w, le, lw, re, rw);
for (; m!=NULL; m=m->next) {
d = m->d;
/* mark_cost++;*/
left_valid = (((le != NULL) && (d->left != NULL) && x_prune_match(ctxt, le, d->left, lw, w)) &&
((region_valid(sent, lw, w, le->next, d->left->next)) ||
((le->multi) && region_valid(sent, lw, w, le, d->left->next)) ||
((d->left->multi) && region_valid(sent, lw, w, le->next, d->left)) ||
((le->multi && d->left->multi) && region_valid(sent, lw, w, le, d->left))));
right_valid = (((d->right != NULL) && (re != NULL) && x_prune_match(ctxt, d->right, re, w, rw)) &&
((region_valid(sent, w, rw, d->right->next,re->next)) ||
((d->right->multi) && region_valid(sent, w,rw,d->right,re->next)) ||
((re->multi) && region_valid(sent, w, rw, d->right->next, re)) ||
((d->right->multi && re->multi) && region_valid(sent, w, rw, d->right, re))));
/* The following if statements could be restructured to avoid superfluous calls
to mark_region. It didn't seem a high priority, so I didn't optimize this.
*/
if (left_valid && region_valid(sent, w, rw, d->right, re)) {
d->marked = TRUE;
mark_region(sent, w, rw, d->right, re);
mark_region(sent, lw, w, le->next, d->left->next);
if (le->multi) mark_region(sent, lw, w, le, d->left->next);
if (d->left->multi) mark_region(sent, lw, w, le->next, d->left);
if (le->multi && d->left->multi) mark_region(sent, lw, w, le, d->left);
}
if (right_valid && region_valid(sent, lw, w, le, d->left)) {
d->marked = TRUE;
mark_region(sent, lw, w, le, d->left);
mark_region(sent, w, rw, d->right->next,re->next);
if (d->right->multi) mark_region(sent, w,rw,d->right,re->next);
if (re->multi) mark_region(sent, w, rw, d->right->next, re);
if (d->right->multi && re->multi) mark_region(sent, w, rw, d->right, re);
}
if (left_valid && right_valid) {
d->marked = TRUE;
mark_region(sent, lw, w, le->next, d->left->next);
if (le->multi) mark_region(sent, lw, w, le, d->left->next);
if (d->left->multi) mark_region(sent, lw, w, le->next, d->left);
if (le->multi && d->left->multi) mark_region(sent, lw, w, le, d->left);
mark_region(sent, w, rw, d->right->next,re->next);
if (d->right->multi) mark_region(sent, w,rw,d->right,re->next);
if (re->multi) mark_region(sent, w, rw, d->right->next, re);
if (d->right->multi && re->multi) mark_region(sent, w, rw, d->right, re);
}
}
put_match_list(sent, m1);
}
}
