C++ parse_int函数代码示例

static int parse_macro_cmd(const char *p, unsigned char *cmd,
                           unsigned char *val)
{
	char *t;
	int q = INVALID_NUMBER, c = INVALID_NUMBER, v = INVALID_NUMBER;

	if (!p || !cmd || !val)
		goto ret;

	t = get_token(p);
	if (t) {
		c = lookup_macro_token_by_name(t);
		free(t);
	}

	if (c == INVALID_NUMBER) {
		v = c;
		goto ret;
	}

	p = skip_token(p);
	/* todo: Q_PLAY */
	if (c == Q_PUSH_META) {
		t = get_token(p);
		if (t) {
			q = lookup_macro_token_by_name(t);
			free(t);
		} else q = INVALID_NUMBER;

		if (q == INVALID_NUMBER) {
			v = q;
			goto ret;
		}

		c |= q;
		p = skip_token(p);
	}

	t = get_token(p);
	switch (get_macro_arg_type(c)) {
	case MACRO_ARG_HID:   v = lookup_hid_token_by_name(t); break;
	case MACRO_ARG_META:  v = parse_meta_handed(p);        break;
	case MACRO_ARG_DELAY: v = parse_int(t, 0, 255);        break;
	case MACRO_ARG_NONE:  v = 0;                           break;
	}
	if (t) free(t);

ret:
	*cmd = (unsigned char)c;
	*val = (unsigned char)v;
	return v == INVALID_NUMBER;
}

	boost::int64_t lazy_entry::int_value() const
	{
		TORRENT_ASSERT(m_type == int_t);
		boost::int64_t val = 0;
		bool negative = false;
		if (*m_data.start == '-') negative = true;
		bdecode_errors::error_code_enum ec = bdecode_errors::no_error;
		parse_int(m_data.start + negative
			, m_data.start + m_size, 'e', val, ec);
		if (ec) return 0;
		if (negative) val = -val;
		return val;
	}

void generator_thread::create_script(QString uuid,QString major, QString minor, int strength){
    QString file_name;
    if(update_minor)
        file_name = uuid+"/"+major+"/start_beacon_"+major+"_"+minor+".sh";
    else
        file_name = uuid+"/"+minor+"/start_beacon_"+major+"_"+minor+".sh";

    //qDebug()<<file_name;
    QFile file(file_name);
    if(file.open(QIODevice::ReadWrite)){
         QTextStream output_stream(&file);
         QString command = "#!/bin/bash \nhciconfig hci0 up\nhciconfig hci0 leadv 3 \n";
         command.append(create_command_string(uuid));
         command.append(parse_int(major.toInt()));
         command.append(parse_int(minor.toInt()));
         command.append(QString::number(strength,16));
         command.append(" 00");
         //qDebug()<<command;
         output_stream<<command;
    }
    file.setPermissions(QFile::ExeGroup | QFile::ReadGroup | QFile::ReadOwner | QFile::ReadOther | QFile::WriteOwner | QFile::ExeUser);
}

irom static app_action_t application_function_gpio_status_set(const string_t *src, string_t *dst)
{
	int io, pin;

	if((parse_int(1, src, &io, 0) == parse_ok) && (parse_int(2, src, &pin, 0) == parse_ok))
	{
		if((io < -1) || (io > io_id_size))
		{
			string_format(dst, "status trigger io %d/%d invalid\n", io, pin);
			return(app_action_error);
		}

		config.status_trigger_io.io = io;
		config.status_trigger_io.pin = pin;
	}

	string_format(dst, "status trigger at io %d/%d (-1 is disabled)\n",
			config.status_trigger_io.io,
			config.status_trigger_io.pin);

	return(app_action_normal);
}

static int
parse_timeout(redisClient *c, robj *obj, int *p) {
    int v;
    if (parse_int(c, obj, &v) != 0) {
        return -1;
    }
    if (v < 0) {
        addReplyErrorFormat(c, "invalid timeout = %d", v);
        return -1;
    }
    *p = (v == 0) ? 100 : v;
    return 0;
}

int
parse_orf_thresh_level(const char *arg, int *x)
{
    int tmp;
    if (parse_int(arg, &tmp)) {
        return -1;
    }
    if (tmp != 0 && tmp != 1 && tmp != 2) {
        return -1;
    }
    *x = tmp;
    return 0;
}

static int
parse_slot(redisClient *c, robj *obj, int *p) {
    int v;
    if (parse_int(c, obj, &v) != 0) {
        return -1;
    }
    if (v < 0 || v >= HASH_SLOTS_SIZE) {
        addReplyErrorFormat(c, "invalid slot number = %d", v);
        return -1;
    }
    *p = v;
    return 0;
}

bool parse_bool(const char *value, bool default_value)
{
    if (!value)
        return default_value;

    if (streq(value, "true") || streq(value, "on") || streq(value, "yes"))
        return true;

    if (streq(value, "false") || streq(value, "off") || streq(value, "no"))
        return false;

    return parse_int(value, default_value);
}

/**
 * Looks up the column index for a range entry. It can be either a column name or a column number.
 * If it is a column number we subtract 1 because human user starts with index 1 rather than 0.
 */
size_t csv_tool::lookup_column_index(const std::string &s) {
	auto it = find_if(csv_data->mcolumns->begin(), csv_data->mcolumns->end(), [s](const meta_column_t &mc) { return mc.title == s; });
	if (it != csv_data->mcolumns->end()) {
		return it - csv_data->mcolumns->begin();
	}
	long long ltmp;
	bool success = parse_int(s, ltmp);
	if (success && ltmp <= csv_data->mcolumns->size()) {
		return ltmp-1;
	} else {
		return std::string::npos;
	}
}

static lwm2m_value parse_value(char *message, int message_len, lwm2m_type type) {
    lwm2m_value value;

    switch(type) {
        case INTEGER: {
            value.int_value = parse_int(message, message_len);
            break;
        }
        case DOUBLE: {
            value.double_value = parse_double(message, message_len);
            break;
        }
        case OPAQUE:
        case STRING: {
            char *string_value = (char *) malloc((size_t) (message_len + 1));
            memcpy(string_value, message, (size_t) message_len);
            string_value[message_len] = '\0';
            value.string_value = string_value;
            break;
        }
        case BOOLEAN: {
            int int_value = parse_int(message, message_len);
            value.bool_value = int_value ? true : false;
            break;
        }
        case LINK: {
            lwm2m_link link;
            link.object_id = parse_int(message + 2, 2);
            link.instance_id = parse_int(message, 2);
            value.link_value = link;
            break;
        }
        default:
            value.int_value = -1;
            break;
    }
    return value;
}

static int mput_cmd(char* args) {
	int i = 0;
	int rv, k, v;
	
	if (th == NULL) {
		fprintf(stderr, "try `open' before `mput'\n");
		return -1;
	}
	
	while (args != NULL && args[0] != '\0') {
		rv = parse_int(&args, &k);
		if (rv != 0) {
			fprintf(stderr, "mput: argument %d not an integer number\n", i);
			return -1;
		}
		
		rv = parse_int(&args, &v);
		if (rv != 0) {
			fprintf(stderr, "mput: value for key %d expected\n", k);
			return -1;
		}
		tapioca_mput(th, &k, sizeof(int), &v, sizeof(int));
		i++;
	}
	
	if (i == 0) {
		fprintf(stderr, "mput: too few arguments\n");
		return -1;
	}
	
	rv = tapioca_mput_commit(th);
	if (rv < 0) {
		fprintf(stderr, "mput: failed.\n");
		return -1;
	}
	printf("committed (%d remote requests)\n", rv);
	return 0;
}

static struct AstNode *parse_literal_int(struct DomNode *dom)
{
    long value;

    if (!dom_node_is_atom(dom)) {
        return NULL;
    }

    if (!parse_int(dom->atom, &value)) {
        return NULL;
    }

    return ast_make_literal_atomic_int(value);
}

expr * simple_parser::parse_expr(scanner & s) {
    builtin_op op; 
    var * v;
    expr * r;
    scanner::token token;
    token = s.scan();
    switch (token) {
    case scanner::LEFT_PAREN:
        token = s.scan();
        if (token != scanner::ID_TOKEN)
            throw parser_error();
        if (m_builtin.find(s.get_id(), op)) {
            ptr_vector<expr> args;
            while (true) {
                expr * arg = parse_expr(s);
                if (arg) {
                    args.push_back(arg);
                }
                else {
                    expr * r = m_manager.mk_app(op.m_family_id, op.m_kind, args.size(), args.c_ptr());
                    m_exprs.push_back(r);
                    return r;
                }
            }
        }
        throw parser_error();
    case scanner::RIGHT_PAREN:
        return 0;
    case scanner::ID_TOKEN:
        if (m_builtin.find(s.get_id(), op)) {
            expr * r = m_manager.mk_const(op.m_family_id, op.m_kind);
            m_exprs.push_back(r);
            return r;
        }
        else if (m_vars.find(s.get_id(), v)) {
            return v;
        }
        throw parser_error();
    case scanner::INT_TOKEN:
        r = parse_int(s.get_number());
        m_exprs.push_back(r);
        return r;
    case scanner::FLOAT_TOKEN:
        r = parse_float(s.get_number());
        m_exprs.push_back(r);
        return r;
    default:
        throw parser_error();
    }
}

int
cmd_disable(mpd_unused int argc, char **argv, mpd_Connection *conn)
{
	int arg;

        if( ! parse_int( argv[0], &arg ) || arg <= 0 ) {
		DIE( "Not a positive integer\n" );
	} else {
		mpd_sendDisableOutputCommand( conn, ( arg - 1 ) );
	}

	mpd_finishCommand( conn );
	return cmd_outputs(0, NULL, conn);
}

static
int try_parse_int(int fd, int *val, const char *pname)
{
	int err;

	err = parse_int(fd, val);

	if (err)
		ERROR("error while parsing %s (%s)", pname,
		      err == -1 ? "end of file" :
		      err == -2 ? "not a number" : "number too big");

	return err;
}