main() { register struct oi_item *o; register struct zone_item *z; register struct bay_item *b; register struct hw_item *h; register struct pw_item *p; extern leave(); open_all(); /*open all files */ for(i = 0;i < NUM_PROMPTS;i++) /*clear the buffers */ for(j = 0;j < BUF_SIZE;j++) buf[i][j] = 0; fix(zero_counts); sd_screen_off(); sd_clear_screen(); sd_text(zero_counts); sd_screen_on(); while(1) { t = sd_input(&fld[0],sd_prompt(&fld[0],0),&rm,buf[0],0); if(t == EXIT) leave(); if(code_to_caps(*buf[0]) == 'y') /* zero the shorts counts */ { sp->sp_sh_printed = 0; sp->sp_sh_count = 0; sp->sp_rs_printed = 0; sp->sp_rs_count = 0; sp->sp_tl_printed = 0; sp->sp_tl_count = 0; sp->sp_sl_printed = 0; sp->sp_sl_count = 0; sp->sp_pl_printed = 0; sp->sp_pl_count = 0; sp->sp_bpl_printed = 0; sp->sp_bpl_count = 0; sp->sp_pl_order = 0; sp->sp_pl_print = 0; sp->sp_sl_order = 0; sp->sp_sl_print = 0; sp->sp_tl_order = 0; sp->sp_tl_print = 0; eh_post(ERR_CONFIRM,"Zero Counts"); break; } else if(code_to_caps(*buf[0]) == 'n') break; else { eh_post(ERR_YN,0); } } if(sp->sp_config_status != 'y') leave(); while(1) { while (1) { t = sd_input(&fld[1],sd_prompt(&fld[1],0),&rm,buf[1],0); if(t == EXIT) leave(); if(code_to_caps(*buf[1]) == 'n' || code_to_caps(*buf[1]) == 'y') break; eh_post(ERR_YN,0); } while (1) { t = sd_input(&fld[2],sd_prompt(&fld[2],0),&rm,buf[2],0); if(t == EXIT) leave(); if(code_to_caps(*buf[2]) == 'n' || code_to_caps(*buf[2]) == 'y') break; eh_post(ERR_YN,0); } if (code_to_caps(*buf[1]) == 'n' && code_to_caps(*buf[2]) == 'n') leave(); if(IS_ONE_PICKLINE) pickline = op_pl; else { if(SUPER_OP) pickline_prompt(); else pickline = op_pl; } if (pickline == 0 && code_to_caps(*buf[1]) == 'y') { for (i = 0; i < coh->co_pl_cnt; i++) /*for all picklines */ { pl[i].pl_complete = 0; } for (i = 0; i < coh->co_zone_cnt; i++) { zone[i].zt_count = 0; } eh_post(ERR_CONFIRM,"Zero counts"); } else if (code_to_caps(*buf[1]) == 'y') { pl[pickline - 1].pl_complete = 0; for (i = 0; i < coh->co_zone_cnt; i++) { if (pickline == zone[i].zt_pl) zone[i].zt_count = 0; } eh_post(ERR_CONFIRM,"Zero counts"); } if (code_to_caps(*buf[2]) == 'y') { sd_wait(); for (i = 0; i < coh->co_pl_cnt; i++) { if (pickline && pl[i].pl_pl != pickline) continue; pl[i].pl_lines_to_go = 0; pl[i].pl_units_to_go = 0; } for (j = 0, p = pw; j < coh->co_prod_cnt; j++, p++) { h = &hw[p->pw_ptr - 1]; if (h->hw_bay) { b = &bay[h->hw_bay - 1]; if (b->bay_zone) { z = &zone[b->bay_zone - 1]; if (pickline && z->zt_pl != pickline) continue; p->pw_units_to_go = 0; p->pw_lines_to_go = 0; } } } for (i = 0, o = oc->oi_tab; i < oc->of_size; i++, o++) { if (!o->oi_pl || !o->oi_on) continue; if (pickline && o->oi_pl != pickline) continue; if (o->oi_queue == OC_COMPLETE) continue; op_rec->pi_pl = o->oi_pl; op_rec->pi_on = o->oi_on; op_rec->pi_mod = 1; pick_startkey(op_rec); op_rec->pi_mod = coh->co_prod_cnt; pick_stopkey(op_rec); begin_work(); while (!pick_next(op_rec, NOLOCK)) { if (op_rec->pi_flags & PICKED) continue; if (op_rec->pi_flags & NO_PICK) continue; pl[op_rec->pi_pl - 1].pl_units_to_go += op_rec->pi_ordered; pl[op_rec->pi_pl - 1].pl_lines_to_go += 1; pw[op_rec->pi_mod - 1].pw_units_to_go += op_rec->pi_ordered; pw[op_rec->pi_mod - 1].pw_lines_to_go += 1; } commit_work(); } eh_post(ERR_CONFIRM, "Zero Remaining:"); } if (SUPER_OP && pickline != 0 && (!(IS_ONE_PICKLINE))) { sd_cursor(0,9,1); sd_clear_line(); sd_cursor(0,10,1); sd_clear_line(); continue; } leave(); } }
main() { register struct pw_item *i; register struct st_item *s; register long k, errors; long pid, status; char command[80]; putenv("_=orphan_picks"); chdir(getenv("HOME")); database_open(); ss_open(); co_open(); oc_open(); od_open(); if (sp->sp_sku_support == 'n') leave(0); errors = 0; tmp_name(fd_name); fd = fopen(fd_name, "w"); if (fd == 0) krash("main", "open temp", 1); if (sp->sp_sku_support == 'y') /* only when sku support */ { for (k = 0, i = pw; k < coh->co_prod_cnt; k++, i++) { if (i->pw_lines_to_go <= 0) continue; /* has no picks */ s = mod_lookup(k + 1); /* find in sku table */ if (s) continue; /* module has a sku */ fprintf(fd, "No SKU Assigned To Module %d Has %d Picks\n", k + 1, i->pw_lines_to_go); errors++; } } #ifdef DEBUG fprintf(stderr, "errors=%d\n", errors); #endif fprintf(fd, "\n\n"); pick_setkey(1); begin_work(); while (!pick_next(op_rec, NOLOCK)) { #ifdef DEBUG fprintf(stderr, "pl=%d on=%d mod=%d flag=%x\n", op_rec->pi_pl, op_rec->pi_on, op_rec->pi_mod, op_rec->pi_flags); #endif commit_work(); begin_work(); if (op_rec->pi_flags & VALIDATED) continue; fprintf(fd, "Pickline: %2d Order: %7.*d Mod: %5d SKU: %-15.15s Quan: %3d\n", op_rec->pi_pl, rf->rf_on, op_rec->pi_on, op_rec->pi_mod, op_rec->pi_sku, op_rec->pi_ordered); errors++; } commit_work(); fclose(fd); if (errors) { tmp_name(ed_name); if (fork() == 0) { execlp("prft", "prft", fd_name, ed_name, "sys/report/orphan_picks.h", 0); krash("main", "load prft", 1); } pid = wait(&status); if (!pid || status) krash("main", "prft failed", 1); sprintf(command, "%s %s", getenv("LPR"), fd_name); } else unlink(fd_name); leave(0); }
static int split_rtree_node(SplitStruct *node, int n_entries, int all_size, /* Total key's size */ int key_size, int min_size, /* Minimal group size */ int size1, int size2 /* initial group sizes */, double **d_buffer, int n_dim) { SplitStruct *cur; SplitStruct *a= NULL, *b= NULL; double *g1 = reserve_coords(d_buffer, n_dim); double *g2 = reserve_coords(d_buffer, n_dim); SplitStruct *next= NULL; int next_node= 0; int i; SplitStruct *end = node + n_entries; if (all_size < min_size * 2) { return 1; } cur = node; for (; cur<end; ++cur) { cur->square = count_square(cur->coords, n_dim); cur->n_node = 0; } pick_seeds(node, n_entries, &a, &b, n_dim); a->n_node = 1; b->n_node = 2; copy_coords(g1, a->coords, n_dim); size1 += key_size; copy_coords(g2, b->coords, n_dim); size2 += key_size; for (i=n_entries - 2; i>0; --i) { if (all_size - (size2 + key_size) < min_size) /* Can't write into group 2 */ { mark_all_entries(node, n_entries, 1); break; } if (all_size - (size1 + key_size) < min_size) /* Can't write into group 1 */ { mark_all_entries(node, n_entries, 2); break; } pick_next(node, n_entries, g1, g2, &next, &next_node, n_dim); if (next_node == 1) { size1 += key_size; mbr_join(g1, next->coords, n_dim); } else { size2 += key_size; mbr_join(g2, next->coords, n_dim); } next->n_node = next_node; } return 0; }
static inline void apply(Node & n, Node & second_node, Box & box1, Box & box2, parameters_type const& parameters, Translator const& translator, Allocators & allocators) { typedef typename rtree::elements_type<Node>::type elements_type; typedef typename elements_type::value_type element_type; typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type; elements_type & elements1 = rtree::elements(n); elements_type & elements2 = rtree::elements(second_node); BOOST_GEOMETRY_INDEX_ASSERT(elements1.size() == parameters.get_max_elements() + 1, "unexpected elements number"); // copy original elements - use in-memory storage (std::allocator) // TODO: move if noexcept typedef typename rtree::container_from_elements_type<elements_type, element_type>::type container_type; container_type elements_copy(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy) container_type elements_backup(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy) // calculate initial seeds size_t seed1 = 0; size_t seed2 = 0; quadratic::pick_seeds<Box>(elements_copy, parameters, translator, seed1, seed2); // prepare nodes' elements containers elements1.clear(); BOOST_GEOMETRY_INDEX_ASSERT(elements2.empty(), "second node's elements container should be empty"); BOOST_TRY { // add seeds elements1.push_back(elements_copy[seed1]); // MAY THROW, STRONG (copy) elements2.push_back(elements_copy[seed2]); // MAY THROW, STRONG (alloc, copy) // calculate boxes detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1); detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2); // remove seeds if (seed1 < seed2) { rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy) elements_copy.pop_back(); rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy) elements_copy.pop_back(); } else { rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy) elements_copy.pop_back(); rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy) elements_copy.pop_back(); } // initialize areas content_type content1 = index::detail::content(box1); content_type content2 = index::detail::content(box2); size_t remaining = elements_copy.size(); // redistribute the rest of the elements while ( !elements_copy.empty() ) { typename container_type::reverse_iterator el_it = elements_copy.rbegin(); bool insert_into_group1 = false; size_t elements1_count = elements1.size(); size_t elements2_count = elements2.size(); // if there is small number of elements left and the number of elements in node is lesser than min_elems // just insert them to this node if ( elements1_count + remaining <= parameters.get_min_elements() ) { insert_into_group1 = true; } else if ( elements2_count + remaining <= parameters.get_min_elements() ) { insert_into_group1 = false; } // insert the best element else { // find element with minimum groups areas increses differences content_type content_increase1 = 0; content_type content_increase2 = 0; el_it = pick_next(elements_copy.rbegin(), elements_copy.rend(), box1, box2, content1, content2, translator, content_increase1, content_increase2); if ( content_increase1 < content_increase2 || ( content_increase1 == content_increase2 && ( content1 < content2 || ( content1 == content2 && elements1_count <= elements2_count ) ) ) ) { insert_into_group1 = true; } else { insert_into_group1 = false; } } // move element to the choosen group element_type const& elem = *el_it; indexable_type const& indexable = rtree::element_indexable(elem, translator); if ( insert_into_group1 ) { elements1.push_back(elem); // MAY THROW, STRONG (copy) geometry::expand(box1, indexable); content1 = index::detail::content(box1); } else { elements2.push_back(elem); // MAY THROW, STRONG (alloc, copy) geometry::expand(box2, indexable); content2 = index::detail::content(box2); } BOOST_GEOMETRY_INDEX_ASSERT(!elements_copy.empty(), "expected more elements"); typename container_type::iterator el_it_base = el_it.base(); rtree::move_from_back(elements_copy, --el_it_base); // MAY THROW, STRONG (copy) elements_copy.pop_back(); BOOST_GEOMETRY_INDEX_ASSERT(0 < remaining, "expected more remaining elements"); --remaining; } } BOOST_CATCH(...) { //elements_copy.clear(); elements1.clear(); elements2.clear(); rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_backup, allocators); //elements_backup.clear(); BOOST_RETHROW // RETHROW, BASIC }