static int print_circle_prefix(ios_t *f, value_t v) { value_t label; char buf[64]; char *str; if ((label=(value_t)ptrhash_get(&printconses, (void*)v)) != (value_t)HT_NOTFOUND) { if (!ismarked(v)) { //HPOS+=ios_printf(f, "#%ld#", numval(label)); outc('#', f); str = uint2str(buf, sizeof(buf)-1, numval(label), 10); outs(str, f); outc('#', f); return 1; } //HPOS+=ios_printf(f, "#%ld=", numval(label)); outc('#', f); str = uint2str(buf, sizeof(buf)-1, numval(label), 10); outs(str, f); outc('=', f); } if (ismanaged(v)) unmark_cons(v); return 0; }
// size of out_str can be up to (3*sizeof(int) + 2) int int2str(int value, char* out_str) { if (value < 0) { out_str[0] = '-'; return uint2str( (unsigned int) (-value), out_str + 1 ) + 1; } return uint2str( (unsigned int) value, out_str ); }
static char *int2str(long long value, char *buf) { if (value < 0) { *buf++ = '-'; value = -value; } return uint2str(value, buf); }
void Console::putui(const unsigned int _n) { char foostr[15]; uint2str(_n, foostr); putch('<'); puts(foostr); putch('>'); }
/** * Log statistics. */ void StatCalc::log(int generation) { if(generation == -1) generation = statNo; ECF_LOG(state_, 3, "Evaluations: " + uint2str(evaluations_[generation]) + "\nStats: fitness\n\tmax: " + dbl2str(max_[generation]) + "\n\tmin: " + dbl2str(min_[generation]) + "\n\tavg: " + dbl2str(average_[generation]) + "\n\tstdev: " + dbl2str(stdDev_[generation]) + "\n"); }
DLLEXPORT jl_sym_t *jl_gensym(void) { static char name[16]; char *n; n = uint2str(&name[2], sizeof(name)-2, gs_ctr, 10); *(--n) = '#'; *(--n) = '#'; gs_ctr++; return jl_symbol(n); }
bool TermStagnationOp::operate(StateP state) { uint currentGen = state->getGenerationNo(); if(currentGen - state->getPopulation()->getHof()->getLastChange() > termStagnation_) { state->setTerminateCond(); ECF_LOG(state, 1, "Termination: maximum number of generations without improvement (" + uint2str(termStagnation_) + ") reached"); } return true; }
static jl_sym_t *scmsym_to_julia(value_t s) { assert(issymbol(s)); if (fl_isgensym(s)) { static char gsname[16]; char *n = uint2str(&gsname[1], sizeof(gsname)-1, ((gensym_t*)ptr(s))->id, 10); *(--n) = '#'; return jl_symbol(n); } return jl_symbol(symbol_name(s)); }
DLLEXPORT jl_sym_t *jl_tagged_gensym(const char* str, int32_t len) { static char gs_name[14]; char name[sizeof(gs_name)+len+3]; char *n; name[0] = '#'; name[1] = '#'; name[2+len] = '#'; memcpy(name+2, str, len); n = uint2str(gs_name, sizeof(gs_name), gs_ctr, 10); memcpy(name+3+len, n, sizeof(gs_name)-(n-gs_name)); gs_ctr++; return jl_symbol(name); }
DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len) { static char gs_name[14]; char *name = (char*)alloca(sizeof(gs_name)+len+3); char *n; name[0] = '#'; name[1] = '#'; name[2+len] = '#'; memcpy(name+2, str, len); n = uint2str(gs_name, sizeof(gs_name), gs_ctr, 10); memcpy(name+3+len, n, sizeof(gs_name)-(n-gs_name)); if (strlen(name) != len+3+sizeof(gs_name)-(n-gs_name)-1) jl_exceptionf(jl_argumenterror_type, "Symbol name may not contain \\0"); gs_ctr++; return jl_symbol(name); }
JL_DLLEXPORT jl_sym_t *jl_tagged_gensym(const char *str, int32_t len) { char gs_name[14]; if (memchr(str, 0, len)) jl_exceptionf(jl_argumenterror_type, "Symbol name may not contain \\0"); char *name = (char*) (len >= 256 ? malloc(sizeof(gs_name)+len+3) : alloca(sizeof(gs_name)+len+3)); char *n; name[0] = '#'; name[1] = '#'; name[2+len] = '#'; memcpy(name+2, str, len); n = uint2str(gs_name, sizeof(gs_name), gs_ctr, 10); memcpy(name+3+len, n, sizeof(gs_name)-(n-gs_name)); gs_ctr++; jl_sym_t *sym = _jl_symbol(name, len+3+sizeof(gs_name)-(n-gs_name)-1); if (len >= 256) free(name); return sym; }
static uint8_t tui_nummenu_printer(unsigned char* buf, int32_t val) { return uint2str(buf,(uint16_t)val); }
static void __vprintk(const char *fmt, va_list ap) { char buf[128]; char *p, *p0; char c, fill; unsigned long long v; unsigned int width; bool longmode; p = buf; while (1) { c = *fmt++; if (c == 0) break; else if (c == '%') { *p = 0; console_write(buf); p = buf; c = *fmt++; width = 0; p0 = p; fill = (c == '0') ? '0' : ' '; while (c >= '0' && c <= '9') { width = width * 10 + c - '0'; c = *fmt++; if (width >= sizeof(buf) - 1) width = 0; } longmode = false; if (c == 'l') { longmode = true; c = *fmt++; } switch (c) { case 'd': if (longmode) v = va_arg(ap, long); else v = va_arg(ap, int); p = int2str(v, p); p = align(p, p0, width, fill); break; case 'p': *p++ = '0'; *p++ = 'x'; v = va_arg(ap, unsigned long); p = hex2str(v, p, (unsigned long)-1); break; case 's': console_write(va_arg(ap, const char *)); break; case 'u': if (longmode) v = va_arg(ap, unsigned long); else v = va_arg(ap, unsigned int); p = uint2str(v, p); p = align(p, p0, width, fill); break; case 'x': if (longmode) v = va_arg(ap, unsigned long); else
void DCDCBoost2xGAController::setCurrentState(unsigned int inState) { switch(inState){ case 0: (*this)[0]->setState(false); (*this)[1]->setState(true); (*this)[2]->setState(true); break; case 1: (*this)[0]->setState(true); (*this)[1]->setState(false); (*this)[2]->setState(true); break; case 2: (*this)[0]->setState(true); (*this)[1]->setState(true); (*this)[2]->setState(false); break; // case 3: // (*this)[0]->setState(true); // (*this)[1]->setState(false); // (*this)[2]->setState(false); // break; default: throw runtime_error(string("DCDCBoost2xGAController::setCurrentState invalid state ")+uint2str(inState)); } }
void fl_print_child(ios_t *f, value_t v) { char *name, *str; char buf[64]; if (print_level >= 0 && P_LEVEL >= print_level && (iscons(v) || isvector(v) || isclosure(v))) { outc('#', f); return; } P_LEVEL++; switch (tag(v)) { case TAG_NUM : case TAG_NUM1: //HPOS+=ios_printf(f, "%ld", numval(v)); break; str = uint2str(&buf[1], sizeof(buf)-1, labs(numval(v)), 10); if (numval(v)<0) *(--str) = '-'; outs(str, f); break; case TAG_SYM: name = symbol_name(v); if (print_princ) outs(name, f); else if (ismanaged(v)) { outsn("#:", f, 2); outs(name, f); } else print_symbol_name(f, name); break; case TAG_FUNCTION: if (v == FL_T) { outsn("#t", f, 2); } else if (v == FL_F) { outsn("#f", f, 2); } else if (v == FL_NIL) { outsn("()", f, 2); } else if (v == FL_EOF) { outsn("#<eof>", f, 6); } else if (isbuiltin(v)) { if (!print_princ) outsn("#.", f, 2); outs(builtin_names[uintval(v)], f); } else { assert(isclosure(v)); if (!print_princ) { if (print_circle_prefix(f, v)) break; function_t *fn = (function_t*)ptr(v); outs("#fn(", f); char *data = cvalue_data(fn->bcode); size_t i, sz = cvalue_len(fn->bcode); for(i=0; i < sz; i++) data[i] += 48; fl_print_child(f, fn->bcode); for(i=0; i < sz; i++) data[i] -= 48; outc(' ', f); fl_print_child(f, fn->vals); if (fn->env != NIL) { outc(' ', f); fl_print_child(f, fn->env); } if (fn->name != LAMBDA) { outc(' ', f); fl_print_child(f, fn->name); } outc(')', f); } else { outs("#<function>", f); } } break; case TAG_CVALUE: case TAG_CPRIM: if (v == UNBOUND) { outs("#<undefined>", f); break; } case TAG_VECTOR: case TAG_CONS: if (print_circle_prefix(f, v)) break; if (isvector(v)) { outc('[', f); int newindent = HPOS, est; int i, sz = vector_size(v); for(i=0; i < sz; i++) { if (print_length >= 0 && i >= print_length && i < sz-1) { outsn("...", f, 3); break; } fl_print_child(f, vector_elt(v,i)); if (i < sz-1) { if (!print_pretty) { outc(' ', f); } else { est = lengthestimate(vector_elt(v,i+1)); if (HPOS > SCR_WIDTH-4 || (est!=-1 && (HPOS+est > SCR_WIDTH-2)) || (HPOS > SCR_WIDTH/2 && !smallp(vector_elt(v,i+1)) && !tinyp(vector_elt(v,i)))) newindent = outindent(newindent, f); else outc(' ', f); } } } outc(']', f); break; } if (iscvalue(v) || iscprim(v)) cvalue_print(f, v); else print_pair(f, v); break; } P_LEVEL--; }
// size of out_str can be up to (3*sizeof(int) + 1) int uint2strdec(unsigned int value, char* out_str) { return uint2str(value, out_str); }
static int handleget() { var_t *var = NULL; viewvar_t *view = NULL; char out[12] = {0}; char *name = strtok(NULL, ' '); char *arg = NULL; char *subarg = NULL; uint32_t val = 0; uint32_t mask = 0; int idx = 0; int i = 0; if (!name || strlen(name) == 0) return ERRNONAME; if (!(var = getvar(name))) return ERRNOSUCHVAR; switch (var->type) { case NUMTYPE: int2str(out, sizeof(out), ((numvar_t*)var)->num); break; case ARRTYPE: if (!(arg = strtok(NULL, ' '))) return ERRNOARG; idx = str2uint(arg); if (idx >= ((arrvar_t*)var)->size/sizeof(int)) return ERRINVALIDIDX; int2str(out, sizeof(out), ((int*)((arrvar_t*)var)->arr)[idx]); break; case VIEWTYPE: view = (viewvar_t*)var; if (!(arg = strtok(NULL, ' '))) return ERRNOARG; idx = str2uint(arg)*view->view->size; if (view->bytesize) { #ifndef PATCHED if (!(idx+view->view->size < calc_bytesize(view->bytesize))) #else if (!(idx+view->view->size < calc_bytesize(view->bytesize) && calc_bytesize(view->bytesize) < view->arr->size)) #endif return ERRINVALIDIDX; } else if (idx+view->view->size > view->arr->size) { return ERRINVALIDIDX; } for(i=0; i < view->view->size; i++) val |= view->arr->arr[i+idx] << (i*8); if (view->view->sign) { if (view->view->size == sizeof(int)) int2str(out, sizeof(out), val); else if (view->view->size == sizeof(short)) int2str(out, sizeof(out), (short)val); else if (view->view->size == sizeof(char)) int2str(out, sizeof(out), (char)val); } else { uint2str(out, sizeof(out), val); } break; default: return ERRNOSUCHTYPE; } SSENDL(strlen(out),out); return 0; }
/* convert a boot_image at kernel_addr into a kernel + ramdisk + tags */ int ready_for_jump(unsigned char* data_buf, unsigned int data_size) { int i; unsigned kernel_actual; unsigned page_mask; char initrd_param[64]; unsigned int pos; unsigned long dsize = 0; unsigned char *bulk_data_buf; static unsigned long bulk_data_size = 0; static u32 *param_addr = 0; static u8 *tmpbuf = 0; #ifndef CONFIG_BURNER static u8 cmdline[256] = CONFIG_BOOTARGS; #else static u8 cmdline[256] = {0,}; #endif if (data_buf == NULL) { return -EINVAL; } bulk_data_buf = data_buf; if (data_size != 0) { dsize = data_size; } else { dsize = bulk_data_size; } memcpy(&bootimginfo, bulk_data_buf, 2048); for (i = 0; i < dsize; i++) { bulk_data_buf[i] = bulk_data_buf[2048 + i]; } page_mask = bootimginfo.page_size - 1; kernel_actual = (bootimginfo.kernel_size + page_mask) & (~page_mask); bootimginfo.kernel_addr = (unsigned int)bulk_data_buf; bootimginfo.ramdisk_addr = bootimginfo.kernel_addr + kernel_actual; memcpy((u8 *)CONFIG_RAMDISK_DST, (char *)bootimginfo.ramdisk_addr, bootimginfo.ramdisk_size); /* Prepare kernel parameters and environment */ param_addr = (u32 *)CONFIG_PARAM_BASE; /* might be address of ascii-z string: "memsize" */ param_addr[0] = 0; /* might be address of ascii-z string: "0x01000000" */ param_addr[1] = 0; param_addr[2] = 0; param_addr[3] = 0; param_addr[4] = 0; param_addr[5] = CONFIG_PARAM_BASE + 32; param_addr[6] = (u32)data_buf; tmpbuf = (u8 *)(CONFIG_PARAM_BASE + 32); memset(initrd_param, 0, 40); strcpy((char *)initrd_param, " rd_start=0x"); pos = strlen(initrd_param); uint2str(CONFIG_RAMDISK_DST, (unsigned char *)(initrd_param + pos)); pos = strlen(initrd_param); strcpy((char *)(initrd_param + pos), " rd_size=0x"); pos = strlen(initrd_param); uint2str(bootimginfo.ramdisk_size, (unsigned char *)(initrd_param + pos)); pos = strlen((char *)cmdline); strcpy((char *)(cmdline + pos), initrd_param); for (i = 0; i < 256; i++) tmpbuf[i] = cmdline[i]; printf("cmdline: %s\n",(char *)cmdline); return 0; }
int main(int argc, char **argv) { // run for selected COCO functions for(uint function = 1; function < 25; function++) { // read XML config std::ifstream fin(argv[1]); if (!fin) { throw std::string("Error opening file! "); } std::string xmlFile, temp; while (!fin.eof()) { getline(fin, temp); xmlFile += "\n" + temp; } fin.close(); // set log and stats parameters std::string funcName = uint2str(function); std::string logName = "log", statsName = "stats"; if(function < 10) { logName += "0"; statsName += "0"; } logName += uint2str(function) + ".txt"; statsName += uint2str(function) + ".txt"; // update in XML XMLResults results; XMLNode xConfig = XMLNode::parseString(xmlFile.c_str(), "ECF", &results); XMLNode registry = xConfig.getChildNode("Registry"); XMLNode func = registry.getChildNodeWithAttribute("Entry", "key", "coco.function"); func.updateText(funcName.c_str()); XMLNode log = registry.getChildNodeWithAttribute("Entry", "key", "log.filename"); log.updateText(logName.c_str()); XMLNode stats = registry.getChildNodeWithAttribute("Entry", "key", "batch.statsfile"); stats.updateText(statsName.c_str()); // write back std::ofstream fout(argv[1]); fout << xConfig.createXMLString(true); fout.close(); // finally, run ECF on single function StateP state (new State); //set newAlg MyAlgP alg = (MyAlgP) new MyAlg; state->addAlgorithm(alg); // set the evaluation operator state->setEvalOp(new FunctionMinEvalOp); state->initialize(argc, argv); state->run(); } return 0; }
// somewhat standardish printf. // no floats today int cprintf(const char *fmt, ...) { int i=0; unsigned int u=0; char *s=0; int cnt = 0; va_list argp; va_start(argp, fmt); while (*fmt) { if (*fmt != '%') { cputc(*fmt); } else { ++fmt; int zero = 0; int width = 0; int left = 0; int plus = 0; int ucase = 0; int precis = 0; int done = 0; while (!done) { switch (*fmt) { case '-': left = 1; break; case '+': plus = 1; break; case '.': precis = -1; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (precis) { if (precis == -1) { precis = (*fmt)-'0'; } else { precis = (precis*10) + ((*fmt)-'0'); } } else { if (width == 0) { if (*fmt == '0') { // this i a zero pad specifier zero=1; } else { width = (*fmt)-'0'; } } else { width = (width*10) + ((*fmt)-'0'); } } break; case 'c': // char i = va_arg(argp, int); conio_sprintfbuf[0]=i; conio_sprintfbuf[1]='\0'; cnt += fmt_print(conio_sprintfbuf, 0, width, left, precis, 0); done = 1; break; case 'i': // decimal case 'd': // decimal i = va_arg(argp, int); s = int2str(i); strcpy(conio_sprintfbuf, s); cnt += fmt_print(conio_sprintfbuf, zero, width, left, precis, plus); done = 1; break; case 'u': // unsigned decimal u = va_arg(argp, unsigned int); s = uint2str(u); strcpy(conio_sprintfbuf, s); cnt += fmt_print(conio_sprintfbuf, zero, width, left, precis, plus); done = 1; break; case 's': // string s = va_arg(argp, char*); cnt += fmt_print(s, 0, width, left, precis, 0); done = 1; break; case 'X': // uppercase hex ucase = 1; // fall through case 'x': // hex (a little inefficient..) u = va_arg(argp, unsigned int); i = (u&0xf000)>>12; if (i>9) i+=7; conio_sprintfbuf[0]=i+'0'; i = (u&0xf00)>>8; if (i>9) i+=7; conio_sprintfbuf[1]=i+'0'; i = (u&0xf0)>>4; if (i>9) i+=7; conio_sprintfbuf[2]=i+'0'; i = (u&0xf); if (i>9) i+=7; conio_sprintfbuf[3]=i+'0'; conio_sprintfbuf[4]='\0'; if (!zero) { // remove leading zeros while (conio_sprintfbuf[0]=='0') { // my memcpy is safe in this direction only... memcpy(&conio_sprintfbuf[0], &conio_sprintfbuf[1], 4); // includes NUL } if (conio_sprintfbuf[0] == '\0') { conio_sprintfbuf[0]='0'; conio_sprintfbuf[1]='\0'; } } if (!ucase) { // make lowercase for (int idx=0; idx<4; ++idx) { if ((conio_sprintfbuf[idx]>='A')&&(conio_sprintfbuf[idx]<='F')) { conio_sprintfbuf[idx]+=32; // make lowercase } } } cnt += fmt_print(conio_sprintfbuf, 0, width, left, precis, 0); done = 1; break; case 'o': // octal (roughly same as hex) u = va_arg(argp, unsigned int); i = (u&0x8000)>>15; conio_sprintfbuf[0]=i+'0'; i = (u&0x7000)>>12; conio_sprintfbuf[1]=i+'0'; i = (u&0x0e00)>>9; conio_sprintfbuf[2]=i+'0'; i = (u&0x01c0)>>6; conio_sprintfbuf[3]=i+'0'; i = (u&0x0038)>>3; conio_sprintfbuf[4]=i+'0'; i = (u&0x0007); conio_sprintfbuf[5]=i+'0'; conio_sprintfbuf[6]='\0'; if (!zero) { // remove leading zeros while (conio_sprintfbuf[0]=='0') { // my memcpy is safe in this direction only... memcpy(&conio_sprintfbuf[0], &conio_sprintfbuf[1], 6); // includes NUL } if (conio_sprintfbuf[0] == '\0') { conio_sprintfbuf[0]='0'; conio_sprintfbuf[1]='\0'; } } cnt += fmt_print(conio_sprintfbuf, 0, width, left, precis, 0); done = 1; break; case '%': // percent sign cputc('%'); ++cnt; done = 1; break; // probably useful... //case 'e': // exp float (no support) //case 'f': // float (no support) case '\0': // error - end of string --fmt; break; default: cputc(*fmt); ++cnt; done = 1; break; } ++fmt; } --fmt; // make up for the extra increment } ++fmt; } return cnt; }
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------// int main(int argc, char *argv[]) { int rc; if (argc != 1) { if ( (strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "-help") == 0) || (strcmp(argv[1], "--help") == 0) ) { printf("example: %s\n", argv[0]); return 0; } } rc = uint2str(); if (rc == -1) return 1; rc = sint2str(); if (rc == -1) return 1; rc = is_hex(); if (rc == -1) return 1; rc = is_udec(); if (rc == -1) return 1; rc = is_sdec(); if (rc == -1) return 1; rc = is_uint_string_overflow(); if (rc == -1) return 1; rc = is_sint_string_overflow(); if (rc == -1) return 1; rc = hex2uint(); if (rc == -1) return 1; rc = hex2sint(); if (rc == -1) return 1; rc = sign_expand(); if (rc == -1) return 1; /* // convert dec string to uint bool dec2uint(uint64_t &result, uint64_t default_value, const char *pstr, size_t size); bool dec2uint(uint64_t &result, uint64_t default_value, const char *pstr); bool dec2uint(uint64_t &result, uint64_t default_value, const std::string &str); bool dec2uint(uint64_t &result, const char *pstr, size_t size); bool dec2uint(uint64_t &result, const char *pstr); bool dec2uint(uint64_t &result, const std::string &str); */ rc = dec2sint(); if (rc == -1) return 1; rc = str2uint(); if (rc == -1) return 1; rc = str2bool(); if (rc == -1) return 1; /* // convert byte to hex string const char *bin2hex(const uint8_t byte, bool flag_up = false); // convert sibmol to number, example: '0' -> 0, 'F' -> 15 bool hex2bin(uint8_t source, uint8_t &target); // block read from handle size_t blk_read(int handle, off64_t offset, void *pdata, size_t size); // block write to handle size_t blk_write(int handle, off64_t offset, const void *pdata, size_t size, bool flag_sync = false); // block recv from handle size_t blk_recv(int handle, void *pdata, size_t size); // block send to handle size_t blk_send(int handle, const void *pdata, size_t size); // file open read only int file_open_ro(const char *pfilename); // file open read/write int file_open_rw(const char *pfilename, bool flag_truncate = false, bool flag_excl = false); // file close int file_close(int handle, bool flag_sync = false); // read data from exist file int file_get(const char *pfilename, off_t offset, void *pdata, size_t data_size); int file_get(const char *pfilename, void **pdata, size_t *data_size); int file_get(const char *pfilename, std::string &data); // write data to exist file int file_set(const char *pfilename, off_t offset, const void *pdata, size_t data_size, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false); int file_set(const char *pfilename, off_t offset, const std::string &data, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false); int file_set(const char *pfilename, const std::string &data, bool flag_sync = false, bool flag_truncate = false, bool flag_excl = false); // return (concat str1 and str2) or NULL char *concat_str(const char *pstr1, const char *pstr2); // get env var and convert to bool bool env2bool(bool &result, bool value_default, const char *pname); */ rc = get_signal_name(); if (rc == -1) return 1; rc = flip(); if (rc == -1) return 1; rc = remove_file_ext(); if (rc == -1) return 1; /* // check ipv4 string like '127.0.0.1' bool is_ipaddress(const char *str); // set signal bool set_signal(int signo, void (*sig_handler)(int)); // string to lower void strtolower(const std::string &source, std::string &target); // check pointer and strlen size_t strlen(const char *pstr); */ rc = find(); if (rc == -1) return 1; rc = bin2print(); if (rc == -1) return 1; rc = rnd(); if (rc == -1) return 1; return 0; }
void UintConfigElement::Write(XmlWriter& writer, xmlNode* father) const { if (*m_val != m_def) writer.WriteElement(father, m_name, uint2str(*m_val), m_attribute); }