SplitState filterGraph(PartitionStack* ps, const GraphType& points, const CellList& cells, int path_length) { // Would not normally go this low level, but it is important this is fast memset(&(mset.front()), 0, mset.size() * sizeof(mset[0])); edgesconsidered = 0; MonoSet monoset(ps->cellCount()); debug_out(3, "EdgeGraph", "filtering: " << cells.size() << " cells out of " << ps->cellCount()); if(path_length == 1) { for(int c : cells) { hashCellSimple(ps, points, monoset, c); } } else { MonoSet hitvertices(ps->domainSize()); for(int c : cells) { hashRangeDeep(ps, points, monoset, hitvertices, ps->cellRange(c)); } memset(&(msetspare.front()), 0, msetspare.size() * sizeof(msetspare[0])); hashRangeDeep2(ps, points, monoset, hitvertices.getMembers()); for(int i : range1(mset.size())) { mset[i] += msetspare[i] * 71; } } debug_out(3, "EdgeGraph", "filtering " << mset << " : " << monoset); return filterPartitionStackByFunctionWithCells(ps, SquareBrackToFunction(&mset), monoset); }
int Theme::populateANYThemes(Fl_Browser *o,std::string checkHERE,bool backone){ debug_out("int populateANYThemes(Fl_Browser *o,std::string "+checkHERE+",bool backone)"); if(backone){o->add("..");} DIR *dir=NULL; std::string itemName; struct dirent *ent=NULL; if ((dir = opendir (checkHERE.c_str())) != NULL) { while ((ent = readdir (dir)) != NULL) { itemName=ent->d_name; std::string fullpath=ent->d_name; itemName=itemName.substr(0,(itemName.length())); if (!(itemName.compare(".")==0)&&!(itemName.compare("..")==0)&&!(itemName.compare("old")==0)&&!(itemName.compare("2.3.0")==0)){ //Don't add our random stuff if( (!linuxcommon::has_file_extention_at_end(itemName,".in")) && !linuxcommon::has_file_extention_at_end(itemName,".txt") ){ pugi::xml_document tmp; if(checkHERE.rfind('/')!=checkHERE.length()-1){checkHERE+="/";} std::string subber = checkHERE+fullpath; fullpath=checkHERE+fullpath+"/"+fullpath; debug_out(fullpath); if( (tmp.load_file(fullpath.c_str())) || (tmp.load_file( subber.c_str())) ){ o->add(itemName.c_str()); } } } } if(dir!=NULL){closedir (dir);} } else { perror (""); return EXIT_FAILURE; } return 0; }
SplitState filterPartitionStackByUnorderedFunction(PartitionStack* ps, F f) { debug_out(3, "filterUnFun", "prestate " << ps->printCurrentPartition()); int cellCount = ps->cellCount(); // first of all, we need to try to distinguish as many values of F as possible. std::map<typename F::result_type, HashType> full_hash; for(int i : range1(cellCount)) { typedef std::map<typename F::result_type, unsigned> map_type; map_type count_map; for(int x : ps->cellRange(i)) { count_map[f(x)]++; } for(const auto& m : count_map) { full_hash[m.first] = hash_combine(full_hash[m.first], i, m.second); } } debug_out(3, "filter", "Hash:" << full_hash); debug_out(3, "filter", "Function:" << f); SplitState ret = filterPartitionStackByFunction(ps, IndirectFunction(MapToFunction(&full_hash), f)); debug_out(3, "filterUnFun", "poststate " << ps->printCurrentPartition()); return ret; }
void JSM_Menu::listMenus(Fl_Browser* list_browser){ debug_out("void listMenus(Fl_Browser* o)"); list_browser->clear(); std::string tempString,convertString,tempString2,convertString2,attributeValue,test1,test2; if(newStyle() == -1){ for (int i = 0; i<=9;i++){ convertString = convert(i); if(!isRootMenu(convertString)){ debug_out("Adding: "+convertString); list_browser->add(convertString.c_str()); } } } else{ debug_out("New Style Menu"); for(char i = '0';i<='z';i++){ convertString=i; if((i < ':')||(i > '`')){ if(!isRootMenu(convertString)){ debug_out("Adding: "+convertString); list_browser->add(convertString.c_str()); } } } } list_browser->redraw(); }
void addSolution(const Permutation& sol) { permutations.push_back(sol); D_ASSERT(sol.size() == orbit_mins.size()); debug_out(3, "SS", "Old orbit_mins:" << orbit_mins); for(int i : range1(sol.size())) { if(sol[i] != i) { int val1 = walkToMinimum(i); int val2 = walkToMinimum(sol[i]); int orbit_min = -1; if(comparison(val1, val2)) orbit_min = val1; else orbit_min = val2; update_orbit_mins(orbit_min, val1); update_orbit_mins(orbit_min, val2); update_orbit_mins(orbit_min, i); update_orbit_mins(orbit_min, sol[i]); } } debug_out(1, "SS", "Solution found"); debug_out(3, "SS", "Sol:" << sol); debug_out(3, "SS", "New orbit_mins:" << orbit_mins); }
// This may throw for invalid domain or level. std::ostream& debug_out(debug_level::flag level, const std::string& domain) { debug_internal::DebugState::domain_map_t& dm = debug_internal::get_debug_state().get_domain_map(); debug_internal::DebugState::domain_map_t::iterator level_map = dm.find(domain); if (level_map == dm.end()) { // no such domain std::string msg = "debug_out(): Debug state doesn't contain the requested domain: \"" + domain + "\"."; if (domain != "default") { debug_out(debug_level::warn, "default") << msg << "\n"; debug_out(debug_level::info, "default") << "Auto-creating the missing domain.\n"; debug_register_domain(domain); debug_out(debug_level::warn, "default") << "The message follows:\n"; return debug_out(level, domain); // try again } // this is an internal error THROW_FATAL(debug_internal_error(msg.c_str())); } debug_internal::DebugState::level_map_t::iterator os = level_map->second.find(level); if (level_map == dm.end()) { std::string msg = std::string("debug_out(): Debug state doesn't contain the requested level ") + debug_level::get_name(level) + " in domain: \"" + domain + "\"."; // this is an internal error THROW_FATAL(debug_internal_error(msg.c_str())); } return *(os->second); }
//Void////////////////////////////////////////////////////////////////// void JSM_Menu::changeMenuInclude(std::string newInclude, std::string old, std::string MENU){ debug_out("void changeMenuInclude(std::string "+newInclude+", std::string "+old+", std::string "+MENU+")"); if((newInclude.compare("")==0)||(old.compare("")==0)||(MENU.compare("")==0)){ debug_out("User sent in an empty value"); return; } }
SplitState filterPartitionStackByUnorderedListFunction(PartitionStack* ps, F f) { debug_out(3, "filterUnListFun", "prestate " << ps->printCurrentPartition()); int cellCount = ps->cellCount(); // first of all, we need to try to distinguish as many values of F as possible. std::map<typename F::result_type::value_type, HashType> full_hash; for(int i : range1(cellCount)) { typedef std::map<typename F::result_type::value_type, unsigned> map_type; map_type count_map; for(int val : ps->cellRange(i)) { for(const auto& val2 : f(val)) count_map[val2]++; } for(const auto& val : count_map) { full_hash[val.first] = hash_combine(full_hash[val.first], i, val.second); } } SplitState ret = filterPartitionStackByFunction(ps, IndirectVecCollapseFunction(MapToFunction(&full_hash), f)); debug_out(3, "filterUnListFun", "poststate " << ps->printCurrentPartition()); return ret; }
int application_start(void) { mxchipInit(); Platform_Init(); UART_Init(); #ifdef RFLowPowerMode ps_enable(); #endif #ifdef MCULowPowerMode mico_mcu_powersave_config(mxEnable); #endif debug_out("\r\n%s\r\nmxchipWNet library version: %s\r\n", APP_INFO, system_lib_version()); debug_out (menu); debug_out ("\nMXCHIP> "); while(1) { Main_Menu(); if(configSuccess){ wNetConfig.wifi_mode = Station; wNetConfig.dhcpMode = DHCP_Client; wNetConfig.wifi_retry_interval = 100; StartNetwork(&wNetConfig); debug_out("connect to %s.....\r\n", wNetConfig.wifi_ssid); configSuccess = 0; debug_out ("\nMXCHIP> "); } } }
VALUE exticonv_local_to_utf8(VALUE local_string) { #if RJB_RUBY_VERSION_CODE < 190 check_kcode(); if(RTEST(objIconvR2J)) { return rb_funcall(objIconvR2J, rb_intern("iconv"), 1, local_string); } else { return local_string; } #else VALUE cEncoding, encoding, utf8; cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding")); encoding = rb_funcall(local_string, rb_intern("encoding"), 0); utf8 = rb_const_get(cEncoding, rb_intern("UTF_8")); if (encoding != utf8) { VALUE ret = rb_funcall(local_string, rb_intern("encode"), 2, utf8, encoding); #if defined(DEBUG) debug_out(local_string); debug_out(ret); #endif return ret; } else { return local_string; } #endif }
std::string JSM_Menu::getItemIcon(int menu, int item, int sub){ debug_out("std::string getItemIcon(int menu, int item, int sub)"); pugi::xml_node noder=getNode(menu, "RootMenu", item); pugi::xml_node node=getSubNode(sub,noder); std::string ret=getAttribute(node,"icon"); debug_out("icon="+ret); return ret; }
/* Calculates the truth value of one lineful of conditions. Returns the point just before the end of line. */ static char *test_line (WEdit *edit_widget, char *p, int *result) { int condition; char operator; char *debug_start, *debug_end; /* Repeat till end of line */ while (*p && *p != '\n') { /* support quote space .mnu */ while ((*p == ' ' && *(p-1) != '\\' ) || *p == '\t') p++; if (!*p || *p == '\n') break; operator = *p++; if (*p == '?'){ debug_flag = 1; p++; } /* support quote space .mnu */ while ((*p == ' ' && *(p-1) != '\\' ) || *p == '\t') p++; if (!*p || *p == '\n') break; condition = 1; /* True by default */ debug_start = p; p = test_condition (edit_widget, p, &condition); debug_end = p; /* Add one debug statement */ debug_out (debug_start, debug_end, condition); switch (operator){ case '+': case '=': /* Assignment */ *result = condition; break; case '&': /* Logical and */ *result &= condition; break; case '|': /* Logical or */ *result |= condition; break; default: debug_error = 1; break; } /* switch */ /* Add one debug statement */ debug_out (&operator, NULL, *result); } /* while (*p != '\n') */ /* Report debug message */ debug_out (NULL, NULL, 1); if (!*p || *p == '\n') p --; return p; }
SortEvent filterCellByFunction_noSortData(PartitionStack* ps, int cell, F f) { // Start at the end, because then the cell we pass to // split remains the same. int cellBegin = ps->cellStartPos(cell); int cellEnd = ps->cellEndPos(cell); // Cheap pass to check if all cells have the same value HashType first_val = f(ps->val(cellBegin)); bool allequal = true; for(int pos = cellBegin + 1; pos < cellEnd && allequal; ++pos) { if(first_val != (HashType)f(ps->val(pos))) allequal = false; } if(allequal) { SortEvent se(cellBegin, cellEnd); debug_out(3, "filter", "all hashes equal: " + toString(first_val)); se.addHashStart(f(ps->val(cellBegin)), cellBegin); se.finalise(); return se; } std::sort(ps->cellStartPtr(cell), ps->cellEndPtr(cell), IndirectSorter(f)); ps->fixCellInverses(cell); int cellsplits = 0; SortEvent se(cellBegin, cellEnd); for(int pos = cellEnd - 2; pos >= cellBegin; --pos) { if(f(ps->val(pos)) != f(ps->val(pos+1))) { se.addHashStart(f(ps->val(pos+1)),pos+1); cellsplits++; if(ps->split(cell, pos+1).hasFailed()) abort(); } } // Have to have information about the first cell too! se.addHashStart(f(ps->val(cellBegin)), cellBegin); se.finalise(); D_ASSERT(cellsplits > 0); debug_out(3, "filter", "Succeeded at: " << cell << ", " << cellsplits << " ( " << (cellEnd - cellBegin) << ", " << cellBegin << ", " << cellEnd << ", " << ps->cellCount() << ")\n"); return se; }
//String//////////////////////////////////////////////////////////////// std::string JSM_Menu::getLabel(std::string MENU){ debug_out("std::string getLabel(std::string "+MENU+")"); if(MENU.compare("")==0){ debug_out("Sent in something empty"); return ""; } std::string thisMenu = getMenuAttribute(MENU,"label"); return thisMenu; }
std::string JSM_Menu::getItemLabel(int menu, int item, int sub){ debug_out("std::string getItemLabel(int menu, int itemline, int sub)"); pugi::xml_node noder=getNode(menu, "RootMenu", item); if(!noder){return "";} pugi::xml_node node=getSubNode(sub,noder); if(!node){return "";} std::string ret=getAttribute(node,"label"); debug_out("label="+ret); return ret; }
/******************************************************************** DBASE_CLEAR Sletter alle informationer i databaserne ********************************************************************/ void dbase_clear(void) { debug_out(" | |==> Cleaning Nick database...\n"); while (nicks_count) nicks_remove(nicks_num[nicks_count-1]->numeric); channels_cleanup(); chanserv_dbase_cleanup(); debug_out(" | \\==> Databases successfully removed from memory...\n"); }
SplitState filterPartitionStackByFunction(PartitionStack* ps, F f) { debug_out(3, "filterByFunction", "prestate " << ps->printCurrentPartition()); SplitState ret(false); if(ps->getAbstractQueue()->hasSortData()) ret = filterPartitionStackByFunction_withSortData(ps, f); else ret = filterPartitionStackByFunction_noSortData(ps, f); debug_out(3, "filterByFunction", "poststate " << ps->printCurrentPartition() << ":" << ret); return ret; }
void server_dump(dbase_server *root, int level) { int i; if ((!root) && (!level)) root = servers; if (root) { for (i = 0; i < level; i++) debug_out("| "); debug_out("%s (%s) - %s\n", root->name, root->numeric, root->desc); for (i = 0; i < root->children_count; i++) server_dump(root->children[i], level+1); } }
void InitializeEventHandler_Send( void ) { key_t key; key = ftok( UI_CTRL_PATHNAME, UI_CTRL_PRJ_ID_OWNER_SIP ); if( ( qidEventSip = msgget( key, 0666 | IPC_CREAT ) ) == -1 ) { debug_out( "Create Sip event queue fail.\n" ); } debug_out( "qidEventSip: %d (K:%d)\n", qidEventSip, key ); }
void Theme::setThemeElementTextwithSub(std::string filename,std::string element,std::string subelement,std::string SUBsubelement){ debug_out("void setThemeElementTextwithSub(std::string "+filename+",std::string "+element+",std::string "+subelement+",std::string "+SUBsubelement+")"); if(!load(filename,false)){return;} std::string temp=getElementText(element,subelement,SUBsubelement); if(temp.compare("")==0){ errorOUT("Did NOT get Button from "+filename); return; } if(!load())debug_out("LOADING base document FAILED"); if(!setElementText(element,subelement,SUBsubelement,temp)){errorOUT("FAILED setting "+element+" with "+temp+" in the main DOC");} else{saveNoRestart();} }
SplitState fix_buildingRBase(const vec1<int>& fixed_values, bool useOrbits, bool useBlocks, bool useOrbitals, bool rootCall = false) { debug_out(3, "scpg", "last depth " << last_depth.get() << " new depth " << fixed_values.size()); D_ASSERT(fixed_values.size() > last_depth.get()); last_depth.set(fixed_values.size()); if(useOrbits) { doCacheCheck(config.useOrbits, tracking_first_found_orbits, [this](const vec1<int>& v){ return this->fillRBaseOrbitPartitionCache(v); }, fixed_values, "orbits"); } if(useBlocks) { doCacheCheck(config.useBlocks, tracking_first_found_blocks, [this](const vec1<int>& v){ return this->fillRBaseBlocksCache(v); }, fixed_values, "blocks"); } if(useOrbitals) { doCacheCheck(config.useOrbitals, tracking_first_found_orbitals, [this](const vec1<int>& v){ return this->fillRBaseOrbitalsCache(v); }, fixed_values, "orbitals"); } SplitState ss(true); int fixed_size = fixed_values.size(); if(useOrbits) { const vec1<int>* part = 0; if(tracking_first_found_orbits.get() >= 0) part = this->getRBaseOrbitPartition_cached(tracking_first_found_orbits.get()); else part = this->getRBaseOrbitPartition_cached(fixed_size); debug_out(3, "scpg", "fix_rBase:orbits"); if(!part->empty()) ss = filterPartitionStackByFunction(ps, SquareBrackToFunction(part)); if(ss.hasFailed()) return ss; } if( ( StabChainConfig::doConsiderIfNonTrivial(config.useOrbitals) && fixed_size == tracking_first_found_orbitals.get() ) || ( config.useOrbitals == StabChainConfig::always ) || ( rootCall ) ) { return signal_changed_generic(range1(ps->cellCount()), identityPermutation()); } return ss; }
// Set the date on the MFD void out_saitek_t::set_date(int year, int month, int day) { if (!a_attached) return; int res; if (a_product == x52_other_device) return; unsigned short datedata = day | (month<<8); unsigned short yeardata = year; res = send_usb(0xC4,datedata); if (res < 0) debug_out(err,"out_saitek: cannot set day to %d and month to %d: %s",day,month,usb_error(res)); res = send_usb(0xC8,yeardata); if (res < 0) debug_out(err,"out_saitek: cannot set year to %d: %s",year,usb_error(res)); }
std::string Theme::getButton(std::string element,std::string themefile){ debug_out("std::string getButton(std::string "+element+")"); if(!load(themefile,false)){return "";} std::string filename=getElementText(element); if(linuxcommon::test_file(filename)){ debug_out(filename+" is a file"); return filename; } debug_out(filename+" is NOT a file still going to try to make it happen..."); if(!load(themefile,false)){return "";} std::vector<std::string> icon_paths=IconPaths(); return linuxcommon::test_file_in_vector_path(filename,icon_paths); }
// Init the library void out_saitek_t::init(void) { debug_out(debug, "out_saitek: searching for a supported Saitek joystick"); bool found = search(); if (found) { // if a joystick was found, attach to it a_attached = attach(); if (a_attached) { debug_out(debug, "out_saitek: setting initial brightness and welcome message"); set_display_brightness(0x7F); set_led_brightness(0x7F); print(ONLINE_MSG); } } }
SplitState filterPartitionStackByFunctionWithCells(PartitionStack* ps, F f, const Cells& cells) { debug_out(3, "filterByFunction", "prestate " << ps->printCurrentPartition()); SplitState ret(false); if(ps->getAbstractQueue()->hasSortData()) { // TODO : Use cells ret = filterPartitionStackByFunction_withSortData(ps, f); } else ret = filterPartitionStackByFunctionWithCells_noSortData(ps, f, cells); debug_out(3, "filterByFunctionWC", "poststate " << ps->printCurrentPartition() << ":" << ret); return ret; }
bool validateFixedCell(PartitionStack* ps, int cell, int hash, F f) { debug_out(3, "filter", "validating fixed cell by hash " << hash); for(int val : ps->cellRange(cell)) { if((int)f(val) != hash) { debug_out(3, "filter", "error: found " << f(val) << " for " << val); return false; } } RECORD_STATS(addSortStat(Stats::Sort(ps->cellSize(cell), 1, true))); return true; }
void CAsyncConnect::startConnect(TSockAddr addr) { debug_out(">>-->>>>> CAsyncConnect::startConnect 00 \n"); if (inProgress) { DBG_C("EE: cntr busy"); debug_out(">>-->>>>> CAsyncConnect::startConnect 01 \n"); return; } this->addr = addr; connected = false; _LIT(KL2Cap, "L2CAP"); if (error0) { DBG_C("EE:CAsyncCC error0"); debug_out(">>-->>>>> CAsyncConnect::startConnect 02 \n"); return; } SAFE_CLOSEDEL(sock); sock = new RSocket(); if (sock->Open(ss, KL2Cap) != KErrNone) { error0 = true; DBG_C("EE: CAsyncCC"); SAFE_DEL(sock); debug_out(">>-->>>>> CAsyncConnect::startConnect 03 \n"); return; } addr.SetPort(7); CAsyncAccept::disableSecurity((TBTSockAddr*)&addr); // char tmp[128]; // resolve(addr, tmp); // //DBG_C("II: !con to [%s]", tmp); inProgress = true; state = S_CONNECTING; sock->Connect(addr, iStatus); //DBG_C("II: wait con ..."); debug_out("sock->Connect: %d", iStatus); SetActive(); //debug_out(">>-->>>>> CAsyncConnect::startConnect 04 \n"); }
void stop_middleware_frontend(int sock) { if (myname[0] == '\0') { debug_out(2, "Not registered!\n"); exit(1); } if (!delete_entry(NSDB, myname)) { debug_out(2, "Failed to delete data from nameserver\n"); exit(1); } myname[0] = '\0'; close(sock); }
// Set the time on the MFD void out_saitek_t::set_time(bool h24, int hour, int minute) { if (!a_attached) return; unsigned short timedata = minute | (hour<<8) | (h24?0x8000:0); int res = send_usb(0xC0,timedata); if (res < 0) debug_out(err,"out_saitek: cannot set time to %c:%c: %s",hour,minute,usb_error(res)); }
// Set the display brightness void out_saitek_t::set_display_brightness(char brightness) { if (!a_attached) return; int res = 0; bool mfd = true; // Turn the lights on for the MFD res = send_usb(mfd?0xB1:0xB2,brightness); if (res < 0) debug_out(err,"out_saitek: error while setting brightness %c on display: %s",brightness,usb_error(res)); }