自学教程：C++ str_to_int函数代码示例

static void			stock_lld(t_struck *s, t_pc *proc, int car){	if ((TYP[0] == 2 || TYP[0] == 4) && TYP[1] == 1 && TMP[1]		> 0 && TMP[1] < REG_NUMBER + 1)	{		if (TYP[0] == 4)		{			REG[TMP[1] - 1][3] = (TMP[0] & 0xff000000) >> 24;			REG[TMP[1] - 1][2] = (TMP[0] & 0x00ff0000) >> 16;			REG[TMP[1] - 1][1] = (TMP[0] & 0x0000ff00) >> 8;			REG[TMP[1] - 1][0] = TMP[0] & 0x000000ff;			if (!str_to_int(REG[TMP[1] - 1], REG_SIZE))				car = 1;			proc->carry = car;		}		if (TYP[0] == 2)		{			REG[TMP[1] - 1][0] = s->map[(IND + TMP[0]) % MEM_SIZE];			REG[TMP[1] - 1][1] = s->map[(IND + TMP[0] + 1) % MEM_SIZE];			REG[TMP[1] - 1][2] = (REG[TMP[1] - 1][0] & 0xf) ? 0xff : 0;			REG[TMP[1] - 1][3] = (REG[TMP[1] - 1][0] & 0xf) ? 0xff : 0;			if (!str_to_int(proc->reg[TMP[1] - 1], REG_SIZE))				car = 1;			proc->carry = car;		}	}

void _initialize(char* argv[]){	slurm_conf_reinit(argv[1]); //load the slurm configuration file	self_id = strdup(slurmctld_conf.control_machine); //get the controller id	num_ctrl = str_to_int(argv[2]); // get the number of controllers	mem_list = c_calloc_2(num_ctrl, 30);	_read_memlist(argv[3]); // read the controller membership list	part_size = str_to_int(argv[4]); //get the partition size	source = c_calloc_2(part_size + 1, 30);	/* fill the node list of the controller (part_size, node_1, node_2, ...) */	resource = c_calloc((part_size + 1) * 30);	strcat(resource, argv[4]); strcat(resource, ",");	/* read workload and fill it in the job queue*/	job_queue = init_queue();	_read_workload(argv[5]);	num_job = job_queue->queue_length;	c_zht_init(argv[6], argv[7]); // initialize the controller as a ZHT client	max_proc_thread = str_to_int(argv[8]);	char *job_output_path = c_calloc(100);	strcpy(job_output_path, "./job_output_");	strcat(job_output_path, argv[9]);	job_output_file = fopen(job_output_path, "w");	c_free(job_output_path);}

////////////////////////////////////////////////////////////////////////////////// @fn validateDate( string date )/// @brief Checks the passed date for validity in format and numbering/// @param string date is the date to be checked/// @return true if the date is valid (in "MM/DD" format with possible real days)/// @return false if the date is invalid///////////////////////////////////////////////////////////////////////////////bool validate::validateDate( string date ) {    int month = 0;           //Number of the month we were sent to check  int day = 0;             //Number of the day we were sent to check  int monthsInAYear = 12;  //Number of months in a year  //This is an array of the number of days in each month, that is:  //31 days in January, 28 (or 29) in February, 31 in March, etc.  int daysInMonth[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };  //Makes sure the date is only 5 characters long, that is, "MM/DD"  if ( date.length() != 5 ) { return false; }  //Grabs the 2 left characters of the date and converts to an integer  month = str_to_int( str_left( date, 2 ) );  //Grabs the 2 right characters of the date and converts to an integer  day = str_to_int( str_right( date, 2 ) );    //Checks to make sure the month number is a valid number  if ( month > monthsInAYear || month <= 0 ) {    return false;    //checks to make sure the day number is valid  } else if ( day > daysInMonth[month - 1] || day <= 0 ) {    return false;  		  }  return true;}

bool rulesSystem::loadFrom(string filename){    unsigned int linepos = 0;  string linecheck;    //Reload the file just in case it wasn't loaded before  m_filename.open(filename);    m_daysNotice = str_to_int(m_filename[linepos]);    linepos++;    m_daysConsecutive = str_to_int(m_filename[linepos]);    linepos++;    m_maxPeopleOff = str_to_int(m_filename[linepos]);    linepos += 2;  linecheck = m_filename[linepos];  do  {      addBlackout(linecheck);        linepos++;    linecheck = m_filename[linepos];      } while(linecheck != "END BLACKOUT LIST");  return true;  }

void test_str_to_int(){  int result, error = -1;  result = str_to_int("999", &error);  print_result(result, error);  result = str_to_int("-999", &error);  print_result(result, error);  //should overflow int  result = str_to_int("9123456789", &error);  print_result(result, error);  //should also overflow  result = str_to_int("-9123456789", &error);  print_result(result, error);  //Should have a conversion error  result = str_to_int("123asdf", &error);  print_result(result, error);}

int main(int argc, char **argv) {	int port;	int length;	init_table(&user_table);		if (argc < 3) {		port = 21;		strcpy(filePath, "./tmp/");	} else if (argc <= 4) {		port = str_to_int(argv[2]);		strcpy(filePath, "./tmp/");	} else if (argc == 5) {		port = str_to_int(argv[2]);		strcpy(filePath, ".");		if (argv[4][0] != '/') {			strcat(filePath, "/");		}		strcat(filePath, argv[4]);		length = strlen(filePath);		if (filePath[length - 1] != '/') {			strcat(filePath, "/");		}	}		printf("port: %d/nroot: %s/n", port, filePath);		if (run_ftp(port, command_handler) == STATUS_ERROR) {		printf("Error building tcp connection!/n");	}	return 0;}

void parse_args(AppArgs *args, int argc, char **argv){	if(argc < 7){		usage(argc, argv);	}	for(int i=1; i<argc; i++){		if(std::string("-h") == argv[i]){			usage(argc, argv);		}		if(argv[i][0] == '-'){			fprintf(stderr, "ERROR: Invalid argument: %s!/n", argv[i]);			exit(1);   		}	}	args->type = argv[1];	args->src_ip = argv[2];	args->src_port = str_to_int(argv[3]);	args->dst_ip = argv[4];	args->dst_port = str_to_int(argv[5]);	args->limit = str_to_int(argv[6]);	if(args->type != "KV"){		fprintf(stderr, "ERROR: only type of KV is supported!/n");		exit(1);   	}	if(args->limit <= 0){		fprintf(stderr, "ERROR: invalid limit option!/n");		exit(1);   	}}

static int find_postion(char *action, int *x, int *y){	char *delimiter_first;	char *delimiter_sec;	char number[10];	char *start;	char copy_length;	delimiter_first = strstr(action, DIGIT_DELIMTER);	if(delimiter_first != NULL){	    delimiter_sec = strstr(delimiter_first + 1, DIGIT_DELIMTER);		if(delimiter_sec != NULL){			memset(number, 0, 10);			start = delimiter_first + 1;			copy_length = delimiter_sec - start; 			memcpy(number,start , copy_length);			*x = str_to_int(number);			memset(number, 0, 10);			start = delimiter_sec + 1;			strcpy(number, start);			*y = str_to_int(number);		}	}}

  void qt_dbtableview_impl :: _restore() {    if (!(_model && _parent && _xml)) return;    if (!_model->columnCount()) return;        string expr = _tag_model + "/columns/column[@number=/"%d/"]";    for(int i=0; i<_model->columnCount(); ++i) {      string s = expr;      s.replace(s.find("%d"), 2, int_to_str(i));      xpath_object_ptr tmp(0);      // hide      tmp = _xml->xpath_eval_expr((s + "/hide[text()!=/"/"]").c_str());      if (tmp->size())        _parent->setColumnHidden(i, str_to_int(tmp->get_content(0)));      // width      tmp = _xml->xpath_eval_expr((s + "/width[text()!=/"/"]").c_str());      if (tmp->size())        _parent->setColumnWidth(i, str_to_int(tmp->get_content(0)));    }        // sort    xpath_object_ptr tmp = _xml->xpath_eval_expr((_tag_model + "/header/sortedColumn[text()!=/"/" and @order!=/"/"]").c_str());    if (tmp->size()) {      if (stricmp(tmp->get_prop(0, "order"), "asc") == 0)        _parent->sortByColumn(str_to_int(tmp->get_content(0)), Qt::AscendingOrder);      else        _parent->sortByColumn(str_to_int(tmp->get_content(0)), Qt::DescendingOrder);    }  }

void serve_response() {    int i;    char **response;    if (strcmp(user->type, COMMENT) == 0) {        response = parse_response_and_text(L_CMT_RES);        if (strcmp(response[C_ROOMNAME], user->roomname) != 0)            return;        sprintf(user->buf, "%s:    %s/n", response[C_CMT_NICK], response[C_CMT_TEXT]);        show_comment();    } else if (strcmp(user->type, UPLOAD) == 0) {        response = parse_response(L_UPLOAD_RES);        if (strcmp(response[C_ROOMNAME], user->roomname) != 0)            return;        if (strcmp(response[C_UPLOAD_USER], user->username) == 0)            return;        user->download->exist_file = 1;        strcpy(user->download->name, response[C_UPLOAD_FILE]);        sprintf(user->buf, "%s uploads %s/n", response[C_UPLOAD_NICK], response[C_UPLOAD_FILE]);        show_uploadfile();    } else if (strcmp(user->type, DOWNLOAD) == 0) {        response = parse_response(L_DOWNLOAD_RES);        if (strcmp(response[C_DOWNLOAD_STATUS], DOWNLOAD_S) == 0) {            response = parse_response_and_text(L_DOWNLOAD_RES_S);            write(user->download->fd, response[C_DOWNLOAD_TEXT], strlen(response[C_DOWNLOAD_TEXT]));        } else if (strcmp(response[C_DOWNLOAD_STATUS], DOWNLOAD_E) == 0) {            close(user->download->fd);            wclear(room.console);            waddstr(room.console, "Finish downloading.");            wrefresh(room.console);        }    } else if (strcmp(user->type, HISTORY) == 0) {    } else if (strcmp(user->type, ONLINE) == 0) {        wclear(members.win);        response = parse_response(L_ONLINE_RES);        if (strcmp(response[C_ROOMNAME], user->roomname) != 0)            return;        response = parse_response(L_ONLINE_RES);        members.online_num = str_to_int(response[C_MEMBER_NUM]);        response = parse_response(members.online_num);        for (i = 0; i < members.online_num; i++)            show_online_member(response[i]);        response = parse_response(L_ONLINE_RES);        members.offline_num = str_to_int(response[C_MEMBER_NUM]);        response = parse_response(members.offline_num);        for (i = 0; i < members.offline_num; i++)            show_offline_member(response[i]);    } else if (strcmp(user->type, NEWROOM) == 0) {    } else {        printf("Unknown response type: {%s}/n", user->type);    }    wmove(target->win, target->x, target->y);    wrefresh(target->win);    free(response);}

////////////////////////////////////////////////////////////////////////////////// @fn time_t str_to_time(string date)/// @brief returns a time_t object made from the passed in string/// @param date is a string in the format MM/DD/YYYY to turn into a time_t/// @ret time_t ojbect made from the passed in date///////////////////////////////////////////////////////////////////////////////time_t validate::str_to_time(string date) {  // Storage for what we return.  time_t return_time;  // Store the current time, too.  time_t now;  time(&now);  // Current tm, too.  tm now_tm;  // Yeah, I'm dereferencing a function.  now_tm = *localtime(&now);  // tm structure for easier storage.  // Initialize to "now" for day/month/year, if any are missing.  tm date_tm(now_tm);  // We don't need these three values.  date_tm.tm_hour = 0;  date_tm.tm_min = 0;  date_tm.tm_sec = 0;  // Clear out any ambiguity.  date = str_strip(date, " ", true, true, true);  date = str_replace_all(date, "-", "/");  date = str_replace_all(date, ".", "/");  date = str_replace_all(date, "//", "/");  date = str_replace_all(date, "|", "/");  date = str_replace_all(date, "_", "/");  vector<string> values = str_find_lines(date, "/", false);  if (values.size() >= 1) {    // tm stores months as 0-11    date_tm.tm_mon = str_to_int(values[0]) - 1;  }  if (values.size() >= 2) {    date_tm.tm_mday = str_to_int(values[1]);  }  if (values.size() >= 3) {    // tm stores years as the distance from 1900    date_tm.tm_year = str_to_int(values[2]) - 1900;  }  return_time = mktime(&date_tm);  return return_time;}

void handle_crunch_flags(int flag_char, /* IN */                         const char *flag_arg, /* IN */                         print_usage_f *print_usage, /* IN */                         const char *appl, /* IN */                         struct common_flags *flags) /* OUT */{    struct crunch_options *options = flags->options;    switch(flag_char)    {    case 'c':        options->use_literal_sequences = 0;        break;    case 'C':        options->use_imprecise_rle = 1;        break;    case 'e':        options->exported_encoding = flag_arg;        break;    case 'm':        if (str_to_int(flag_arg, &options->max_offset) != 0 ||            options->max_offset < 0 || options->max_offset >= 65536)        {            LOG(LOG_ERROR,                ("Error: invalid offset for -m option, "                 "must be in the range of [0 - 65535]/n"));            print_usage(appl, LOG_NORMAL, flags->outfile);            exit(-1);        }        break;    case 'M':        if (str_to_int(flag_arg, &options->max_len) != 0 ||            options->max_len < 0 || options->max_len >= 65536)        {            LOG(LOG_ERROR,                ("Error: invalid offset for -n option, "                 "must be in the range of [0 - 65535]/n"));            print_usage(appl, LOG_NORMAL, flags->outfile);            exit(-1);        }        break;    case 'p':        if (str_to_int(flag_arg, &options->max_passes) != 0 ||            options->max_passes < 1 || options->max_passes >= 65536)        {            LOG(LOG_ERROR,                ("Error: invalid value for -p option, "                 "must be in the range of [1 - 65535]/n"));            print_usage(appl, LOG_NORMAL, flags->outfile);            exit(-1);        }        break;    default:        handle_base_flags(flag_char, flag_arg, print_usage,                          appl, &flags->outfile);    }}

void main(){    char str1[50],str2[50];    int a,b;    gets(str1);    gets(str2);    a=str_to_int(str1);    b=str_to_int(str2);    separate_digits(a,b);}

int main () {		char 	str[10] ;	fgets (str , sizeof (str) , stdin ) ;	str[strlen(str) -1] = 0 ;	str_to_int (str) ;	printf ("input convert to int is %d ./n" , str_to_int (str) ) ;	return 0;}

std::tuple<ATTID , ValueRep, double > PlogGroundProgramBuilder::prAtomFromSymbol(const Clingo::Symbol &s) {    auto *h = s.arguments().begin();    ATTID attid = insert(h->to_string(), attids);    ValueRep atid = insert((h+1)->to_string(),atids);    std::string numstr = (h+2)->to_string();    std::string denumstr = (h+3)->to_string();    int probnum =   str_to_int(numstr.substr(1,numstr.length()-2));    int probdenum = str_to_int(denumstr.substr(1,denumstr.length()-2));    double prob = ((double) probnum)/((double) probdenum);    return std::tuple<ATTID , ValueRep , double>(attid, atid, prob);}

int add_one_file() {    if ((uint64_t)current_addr % 4 == 0) current_addr -= 4;    current_addr += (4 - (((uint64_t)current_addr)%4));    if (current_addr >= init_ref_end) {        return 0;    }    struct cpio_header* header = (struct cpio_header*)VA(current_addr);    current_addr += sizeof(struct cpio_header);    uint32_t name_len = str_to_int(header->namesize, 8);    char* name = malloc_small(name_len + 1);    void* addr_for_free = name;    for (uint32_t i = 0; i < name_len; ++i) {        name[i] = ((char*)VA(current_addr))[i];    }    name[name_len] = 0;    current_addr += name_len;    if (name_len == 11 && strncmp(name, END_OF_ARCHIVE, 11) == 0) {        return 0;    }    while (name_len > 0 && name[0] != '/') {        ++name;        --name_len;    }    uint32_t mode = str_to_int(header->mode, 8);    if (S_ISDIR(mode)) {        mkdir(name);    } else if (S_ISREG(mode)) {        int file = open(name, O_WRONLY|O_CREAT|O_EXCL);        uint32_t filesize = str_to_int(header->filesize, 8);        if ((uint64_t)current_addr % 4 == 0) current_addr -= 4;        current_addr += 4 - ((uint64_t)current_addr)%4;        write(file, VA(current_addr), filesize);        current_addr += filesize;    }    free_block(addr_for_free);    return 1;}

int main(int argc, char **argv) {    int n = str_to_int("+3456");    assert(n == 3456);    n = str_to_int("-234");    assert(n == -234);    n = str_to_int("   -   0");    assert(n == 0);    n = str_to_int("- + 56");    assert(n == 0);    printf("All passed/n");}

void Turing::matrix(){	int n, m;	std::ifstream fin("matrix.txt");	std::string c;	fin >> n >> m;	table.resize(n);	state.resize(n);	values.resize(n);	move_tape.resize(n);	for (int i = 0; i < n; ++i)	{		table[i].resize(m);		state[i].resize(m);		values[i].resize(m);		move_tape[i].resize(m);		for (int j = 0; j < m; ++j)			fin >> table[i][j];	}	for (unsigned int i = 0; i < table.size(); ++i)		for (unsigned int j = 0; j < table[i].size(); ++j)		{			c = table[i][j];			if (c[0] != '*' && c[0] != 'P')				values[i][j] = c[0] - '0';			else if (c[0] == '*')				values[i][j] = 3;			else if (c[0] != 'P')				values[i][j] = 2;			state[i][j] = str_to_int(c, 2, c.length() - 2);			move_tape[i][j] = c[c.length() - 1];		}}

Daemon::Explose*	Daemon::Explose::unserialize(std::stringstream &s, GameObject *owner){  std::stringstream ss;  ss << this->unPack(s);  return (new Explose(owner, str_to_double(this->getData(ss)), str_to_int(this->getData(ss)), str_to_int(this->getData(ss))));}

int ini_read_int(STRING *filename, char* section, STRING *entry, int defaultValue){	STRING *tmp = "#64";	STRING *def = "#64";	ini_read(tmp, filename, section, entry, str_for_int(def, defaultValue));	return str_to_int(tmp);}

int main(int argc, char **argv){    int n;    int i;    char line[1024];    int *result = (int *) malloc(10000000 * sizeof(int));    memset(result, 0, 10000000 * sizeof(int));    int temp;    int flag = 0;    scanf("%d", &n);    for (i = 0; i < n; i++)    {        scanf("%s", line);        temp = str_to_int(line, strlen(line));        result[temp]++;        memset(line, 0, 1024);           }        for (i = 1; i < 10000000; i++)    {        if (result[i] > 1)        {            flag = 1;            printf("%03d-%04d %d/n", (i/10000), (i % 10000), result[i]);        }    }        if (0 == flag)    {        printf("No duplicates./n");    }    return 0;}

static constexpr int str_to_int(const char *p, int v){	if (!*p)		return v;	return str_to_int(p+1, v * 10 + *p-'0');}

static void	parse_cmdline (int argc, char **argv){	int	opt;	opt = do_getopt(argc, argv);	while ( opt != -1 )	{		switch ( opt )		{		    case 'h':			usage(stderr, argv[0]);			exit(0);			break;		    case 'f':			Trunc_file = optarg;			break;		    case 'l':			Trunc_len = str_to_int(optarg);			break;		    default:			usage(stderr, argv[0]);			exit(1);			break;		}		opt = do_getopt(argc, argv);	}}

bool	Daemon::Listener::execEvent(Daemon::Trame &trame){  bool	id = true;  bool	type = true;  std::vector<std::string> v_type = trame.getTargetType();  std::vector<std::string> v_id = trame.getTargetId();  for (size_t i = 0; i < v_id.size(); i++)    {      id = false;      if (this->getId() == str_to_int(v_id[i]))	{	  id = true;	  break;	}    }  for (size_t i = 0; i < v_type.size(); i++)    {      type = false;      if (this->getType() == v_type[i])	{	  type = true;	  break;	}    }  if (id && type && this->isListen(trame))    {      (*(this->_listen[trame.getEvent()]))(trame);      return true;    }  return false;}

static intworker_connection_input_line(struct worker_connection *conn, const char *line){	void *const *contextp, *context;	int percentage;	if (aqueue_count(conn->request_queue) == 0) {		i_error("Input from worker without pending requests: %s", line);		return -1;	}	if (str_to_int(line, &percentage) < 0 ||	    percentage < -1 || percentage > 100) {		i_error("Invalid input from worker: %s", line);		return -1;	}	contextp = array_idx(&conn->request_contexts,			     aqueue_idx(conn->request_queue, 0));	context = *contextp;	if (percentage < 0 || percentage == 100) {		/* the request is finished */		aqueue_delete_tail(conn->request_queue);		if (aqueue_count(conn->request_queue) == 0)			i_free_and_null(conn->request_username);	}	conn->callback(percentage, context);	return 0;}

struct filter *new_filter_host(enum filtertype type, const char *matchstr){    struct filter *f;    char *mask;    int i;    if (!(f = __new_filter(type))) return f;    f->u.addrs.addrstr = strdup(matchstr);    if((mask = strchr(f->u.addrs.addrstr, '/'))) {	*mask++ = 0;	if(!str_to_int(mask, &i)) {	    /* Netmask like foo/24 */	    uint32_t l = 0xffffffff;	    if(i < 0 || i > 32) {		fprintf(stderr, "can't parse netmask /"%s/"/n",			mask);		return NULL;	    }	    if(!i)		l = 0;	    else {		i = 32 - i;		l >>= i; l <<= i;	    }	    f->u.addrs.mask.s_addr = htonl(l);	} else {

/* * Expects a string like "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443/r/n" and returns * an Array as follows: *   [ num_bytes, ip_type, ip, port ] * where: *   - num_bytes is the length of the HAProxy Protocol line (to be removed), a Fixnum. *   - ip_type is :ipv4 or :ipv6, *   - ip is a String, *   - port is a Fixnum * If the string is invalid it returns false. */VALUE Utils_parser_haproxy_protocol(VALUE self, VALUE string){  TRACE();  char *str = NULL;  long len = 0;  struct_haproxy_protocol haproxy_protocol;  VALUE num_bytes, ip_type, ip, port;  if (TYPE(string) != T_STRING)    rb_raise(rb_eTypeError, "Argument must be a String");  str = RSTRING_PTR(string);  len = RSTRING_LEN(string);  haproxy_protocol = struct_haproxy_protocol_parser_execute(str, len);  if (haproxy_protocol.valid == 0)    return Qfalse;  else {    if (haproxy_protocol.ip_type == haproxy_protocol_ip_type_ipv4)      ip_type = symbol_ipv4;    else      ip_type = symbol_ipv6;    ip = rb_str_new((char *)haproxy_protocol.ip_s, haproxy_protocol.ip_len);    port = INT2FIX(str_to_int((char *)haproxy_protocol.port_s, haproxy_protocol.port_len));    num_bytes = INT2FIX(haproxy_protocol.total_len);    return rb_ary_new3(4, num_bytes, ip_type, ip, port);  }}

/* * Expects a string like "1.2.3.4_5060" or "1af:43::ab_9090" and returns * an Array as follows: *   [ ip_type, ip, port ] * where: *   - ip_type is :ipv4 or :ipv6, *   - ip is a String, *   - port is a Fixnum * If the string is invalid it returns false. */VALUE Utils_parser_outbound_udp_flow_token(VALUE self, VALUE string){  TRACE();  char *str = NULL;  long len = 0;  struct_outbound_udp_flow_token outbound_udp_flow_token;  VALUE ip_type, ip, port;  if (TYPE(string) != T_STRING)    rb_raise(rb_eTypeError, "Argument must be a String");  str = RSTRING_PTR(string);  len = RSTRING_LEN(string);  outbound_udp_flow_token = outbound_udp_flow_token_parser_execute(str, len);  if (outbound_udp_flow_token.valid == 0)    return Qfalse;  else {    if (outbound_udp_flow_token.ip_type == outbound_udp_flow_token_ip_type_ipv4)      ip_type = symbol_ipv4;    else      ip_type = symbol_ipv6;    ip = rb_str_new((char *)outbound_udp_flow_token.ip_s, outbound_udp_flow_token.ip_len);    port = INT2FIX(str_to_int((char *)outbound_udp_flow_token.port_s, outbound_udp_flow_token.port_len));    return rb_ary_new3(3, ip_type, ip, port);  }}

static boolparse_sockaddr_components(struct sockaddr_storage *ss,                          const char *host_s,                          const char *port_s, uint16_t default_port,                          const char *s){    struct sockaddr_in *sin = ALIGNED_CAST(struct sockaddr_in *, ss);    int port;    if (port_s && port_s[0]) {        if (!str_to_int(port_s, 10, &port) || port < 0 || port > 65535) {            VLOG_ERR("%s: bad port number /"%s/"", s, port_s);        }    } else {        port = default_port;    }    memset(ss, 0, sizeof *ss);    if (strchr(host_s, ':')) {        struct sockaddr_in6 *sin6            = ALIGNED_CAST(struct sockaddr_in6 *, ss);        sin6->sin6_family = AF_INET6;        sin6->sin6_port = htons(port);        if (!ipv6_parse(host_s, &sin6->sin6_addr)) {            VLOG_ERR("%s: bad IPv6 address /"%s/"", s, host_s);            goto exit;        }    } else {

int calculate(char * input1, char * input2, char op){	int a = str_to_int(input1);	int b = str_to_int(input2);	switch (op)	{	case '+':		return a + b;	case '-':		return a - b;	case '*':		return a * b;	default:		return -1;	}}