コード例 #1
0
ファイル: print.c プロジェクト: SatoHiroki/julia
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;
}
コード例 #2
0
ファイル: int2str.c プロジェクト: tbourg/perso
// 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 );
}
コード例 #3
0
static char *int2str(long long value, char *buf)
{
	if (value < 0) {
		*buf++ = '-';
		value = -value;
	}
	return uint2str(value, buf);
}
コード例 #4
0
ファイル: console.C プロジェクト: nitsood/os-machine-problems
void Console::putui(const unsigned int _n) {
  char foostr[15];

  uint2str(_n, foostr);
  putch('<');
  puts(foostr);
  putch('>');
}
コード例 #5
0
ファイル: StatCalc.cpp プロジェクト: icoric4/Zagreb-Metro
/**
 * 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");
}
コード例 #6
0
ファイル: alloc.c プロジェクト: FizzyP/julia
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);
}
コード例 #7
0
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;
}
コード例 #8
0
ファイル: ast.c プロジェクト: RZEWa60/julia
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));
}
コード例 #9
0
ファイル: alloc.c プロジェクト: FizzyP/julia
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);
}
コード例 #10
0
ファイル: alloc.c プロジェクト: pallmagnusson/julia
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);
}
コード例 #11
0
ファイル: alloc.c プロジェクト: BrianSipple/julia
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;
}
コード例 #12
0
ファイル: tui.c プロジェクト: urjaman/carlcdp
static uint8_t tui_nummenu_printer(unsigned char* buf, int32_t val) {
	return uint2str(buf,(uint16_t)val);
}
コード例 #13
0
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));
	}
	
	
}
コード例 #15
0
ファイル: print.c プロジェクト: SatoHiroki/julia
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--;
}
コード例 #16
0
ファイル: int2str.c プロジェクト: tbourg/perso
// 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);
}
コード例 #17
0
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;
}
コード例 #18
0
ファイル: cmd_boota.c プロジェクト: lxl1140989/dmsdk
/* 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;
}
コード例 #19
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;
}
コード例 #20
0
ファイル: conio_cprintf.c プロジェクト: tursilion/libti99
// 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;
}
コード例 #21
0
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//
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;
}
コード例 #22
0
ファイル: config_element.cpp プロジェクト: fluxer/warmux
void UintConfigElement::Write(XmlWriter& writer, xmlNode* father) const
{
  if (*m_val != m_def)
    writer.WriteElement(father, m_name, uint2str(*m_val), m_attribute);
}