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

static voidparse_time_string(unsigned int *hour, unsigned int *minute, const char *time){	char *hours;	char *minutes;	hours = (char *)malloc(3);	minutes = (char *)malloc(3);	bzero((void *)hours, 3);	bzero((void *)minutes, 3);	if (split_time(&hours, &minutes, time) == 1)	{                /* if the number starts with 0, replace it with a space else                   this string_to_number will interpret it as octal !! */                if ((hours[0] == '0') && (hours[1] != '/0'))			hours[0] = ' ';		if ((minutes[0] == '0') && (minutes[1] != '/0'))			minutes[0] = ' ';		if((string_to_number(hours, 0, 23, hour) == -1) ||			(string_to_number(minutes, 0, 59, minute) == -1)) {			*hour = *minute = (-1);		}	}	if ((*hour != (-1)) && (*minute != (-1))) {		free(hours);		free(minutes);		return;	}	/* If we are here, there was a problem ..*/	print_error("invalid time %s specified, should be HH:MM format", time);}

static PyObject *NumberValue(PyObject *self, PyObject *args){  PyObject *object;  PyObject *result = NULL;  if (!PyArg_ParseTuple(args, "O:NumberValue", &object))    return NULL;    result = PyNumber_Float(object);  if (result)    return result;  PyErr_Clear();  if (PyString_Check(object) || PyUnicode_Check(object))    return string_to_number(object);  /* convert it to a string */  object = object_to_string(object);  if (object) {    result = string_to_number(object);    Py_DECREF(object);  }  else result = NULL;  return result;}

int main(){    number_t a, b, c;    int i;    a = string_to_number("-1.7171");    b = string_to_number("-17.17");    c = zero();    print_number(a);    printf("/n");    print_number(b);    printf("/n");    c = sub_number(a, b);    /*       for(i=-10; i<10; i++) {       c = make_exp(i);       print_number(c);       printf("/n");       }       */    c = mult_num(a, b);    print_number(c);    printf("/n");    return 0;}

struct in_addr *dotted_to_addr(const char *dotted){	static struct in_addr addr;	unsigned char *addrp;	char *p, *q;	unsigned int onebyte;	int i;	char buf[20];	/* copy dotted string, because we need to modify it */	strncpy(buf, dotted, sizeof (buf) - 1);	addrp = (unsigned char *) &(addr.s_addr);	p = buf;	for (i = 0; i < 3; i++) {		if ((q = strchr(p, '.')) == NULL)			return (struct in_addr *) NULL;		*q = '/0';		if (string_to_number(p, 0, 255, &onebyte) == -1)			return (struct in_addr *) NULL;		addrp[i] = (unsigned char) onebyte;		p = q + 1;	}	/* we've checked 3 bytes, now we check the last one */	if (string_to_number(p, 0, 255, &onebyte) == -1)		return (struct in_addr *) NULL;	addrp[3] = (unsigned char) onebyte;	return &addr;}

//==============================================================================static void read_range(const String& input, BoolVector& range,		uint_t min_value, uint_t max_value){	boost::cmatch what;	boost::regex exp("(//d{1,})-(//d{1,})");	StringVector list;	boost::split(list, input, boost::is_any_of(","));	foreach(const String& item, list)	{		uint_t n = 0;		uint_t r1, r2;		if (string_to_number(item, n))			r1 = r2 = n;		else		{			if (!boost::regex_match(item.c_str(), what, exp))				throw std::runtime_error("read_range: incorrect input");			string_to_number(what[1].str(), r1);			string_to_number(what[2].str(), r2);			if (r1 > r2)				std::swap(r1, r2);		}		if (r2 > max_value || r1 < min_value)			throw std::runtime_error("read_range: value is out of range");		if (range.size() <= r2)			range.resize(r2 + 1, false);		for (; r1 <= r2; r1++)			range[r1] = true;	}

// Dumps memory.void command_dump(int number_of_arguments, char **argument){    int length;    int base;    if (number_of_arguments != 2 &&        number_of_arguments != 3)    {        debug_print("Invalid number of arguments. Try 'help %s'./n", argument[0]);        return;    }    string_to_number(argument[1], &base);    if (number_of_arguments == 3)    {        string_to_number(argument[2], &length);    }    else    {        length = 1;    }    debug_print("%u %s/n", length, argument[2]);    debug_memory_dump((void *) base, length);}

static int parse(int c, char **argv, int invert, unsigned int *flags,		const struct ipt_entry *entry, unsigned int *nfcache,		struct ipt_entry_match **match){	struct ipt_ttl_info *info = (struct ipt_ttl_info *) (*match)->data;	unsigned int value;	check_inverse(optarg, &invert, &optind, 0);	switch (c) {		case '2':			if (string_to_number(optarg, 0, 255, &value) == -1)				exit_error(PARAMETER_PROBLEM,				           "ttl: Expected value between 0 and 255");			if (invert)				info->mode = IPT_TTL_NE;			else				info->mode = IPT_TTL_EQ;			/* is 0 allowed? */			info->ttl = value;			break;		case '3':			if (string_to_number(optarg, 0, 255, &value) == -1)				exit_error(PARAMETER_PROBLEM,				           "ttl: Expected value between 0 and 255");			if (invert) 				exit_error(PARAMETER_PROBLEM,						"ttl: unexpected `!'");			info->mode = IPT_TTL_LT;			info->ttl = value;			break;		case '4':			if (string_to_number(optarg, 0, 255, &value) == -1)				exit_error(PARAMETER_PROBLEM,				           "ttl: Expected value between 0 and 255");			if (invert)				exit_error(PARAMETER_PROBLEM,						"ttl: unexpected `!'");			info->mode = IPT_TTL_GT;			info->ttl = value;			break;		default:			return 0;	}	if (*flags) 		exit_error(PARAMETER_PROBLEM, 				"Can't specify TTL option twice");	*flags = 1;	return 1;}

//==============================================================================static bool extract_usb_address(const String &str, uint_t &bus, uint_t &device){	boost::cmatch what;	boost::regex regex("([//d]{1,3}):([//d]{1,3})");	if (!boost::regex_match(str.c_str(), what, regex))		return false;	string_to_number(what[1].str(), bus);	string_to_number(what[2].str(), device);	return true;}

int test2(){    char x[128], y[128];    while(1)     {        scanf("%s", x);        scanf("%s", y);        print_number(mult_number(string_to_number(x), string_to_number(y)));        printf("/n");    }}

int main (int argc, char **argv){  if (argc < 2)    usage ("Invalid number of arguments");  {        const char *const action = argv[1];        Success (*function) (Stream, Connection_Id);    Connection_Id conn_id;    char *host;    int port;    if (! strcmp (action, "--version"))      {        printf ("spdsend %s/n", VERSION);        exit (EXIT_OK);      }        if (! strcmp (action, "--open"))      {        if (argc != 4)          usage ("Invalid number of arguments");        host = argv[2];        port = string_to_number (argv[3], 0, 65535);      }    else      {        if (argc != 3)          usage ("Invalid number of arguments");        conn_id = string_to_number (argv[2], CONNECTION_ID_MIN,                                    CONNECTION_ID_MAX);        if (! strcmp (action, "--close"))          function = close_connection;        else if (! strcmp (action, "--send"))          function = send_command;        else          usage ("Invalid option");      }        {      Stream server = open_server ();      if (server == NONE)        return EXIT_ERROR;            {        int result = (! strcmp (action, "--open")                      ? open_connection (server, host, port)                      : function (server, conn_id));        return (result == OK ? EXIT_OK : EXIT_ERROR);      }    }  }}

static intparse(int c, char **argv, int invert, unsigned int *flags,      const struct ip6t_entry *entry,      unsigned int *nfcache,      struct ip6t_entry_match **match){	struct ip6t_fuzzy_info *fuzzyinfo =		(struct ip6t_fuzzy_info *)(*match)->data;	u_int32_t num;	switch (c) {	case '1':	if (invert)	       	exit_error(PARAMETER_PROBLEM,"Can't specify ! --lower-limit");	if (*flags & IP6T_FUZZY_OPT_MINIMUM)       	      exit_error(PARAMETER_PROBLEM,"Can't specify --lower-limit twice");	if (string_to_number(optarg,1,MAXFUZZYRATE,&num) == -1 || num < 1)			exit_error(PARAMETER_PROBLEM,"BAD --lower-limit");		fuzzyinfo->minimum_rate = num ;		*flags |= IP6T_FUZZY_OPT_MINIMUM;		break;	case '2':	if (invert)		exit_error(PARAMETER_PROBLEM,"Can't specify ! --upper-limit");	if (*flags & IP6T_FUZZY_OPT_MAXIMUM)	   exit_error(PARAMETER_PROBLEM,"Can't specify --upper-limit twice");	if (string_to_number(optarg,1,MAXFUZZYRATE,&num) == -1 || num < 1)		exit_error(PARAMETER_PROBLEM,"BAD --upper-limit");		fuzzyinfo->maximum_rate = num;		*flags |= IP6T_FUZZY_OPT_MAXIMUM;		break ;	default:		return 0;	}	return 1;}

/* Function which parses command options; returns true if it ate an option */static intcreate_parse(int c, char *argv[], void *data, unsigned *flags){	struct ip_set_req_nethash_create *mydata =	    (struct ip_set_req_nethash_create *) data;	ip_set_ip_t value;	DP("create_parse");	switch (c) {	case '1':		if (string_to_number(optarg, 1, UINT_MAX - 1, &mydata->hashsize))			exit_error(PARAMETER_PROBLEM, "Invalid hashsize `%s' specified", optarg);		*flags |= OPT_CREATE_HASHSIZE;		DP("--hashsize %u", mydata->hashsize);				break;	case '2':		if (string_to_number(optarg, 1, 65535, &value))			exit_error(PARAMETER_PROBLEM, "Invalid probes `%s' specified", optarg);		mydata->probes = value;		*flags |= OPT_CREATE_PROBES;		DP("--probes %u", mydata->probes);				break;	case '3':		if (string_to_number(optarg, 0, 65535, &value))			exit_error(PARAMETER_PROBLEM, "Invalid resize `%s' specified", optarg);		mydata->resize = value;		*flags |= OPT_CREATE_RESIZE;		DP("--resize %u", mydata->resize);				break;	default:		return 0;	}	return 1;}

closure *parse_number(FILE *file, closure *accum){    wchar_t c = fgetwc(file);    if(iswdigit(c)){	return parse_number(file, cons(character(c), accum));    } else if(iswspace(c)) {	return string_to_number(reverse(accum));    } else if(c == L')') {	ungetwc(c, file); 	return string_to_number(reverse(accum));    } else {	ungetwc(c, file);	return parse_symbol(file, accum);    }}

number_t mult_number(number_t a, number_t b){    number_t result;    int i, k;    result = string_to_number("0.0");    for (i = 0; i < b.digit_len; i++) {        result = mult_one(10, result);        result = add_number(result, mult_one(b.digit[i], a));    }    k = b.digit_len - b.int_len;    if (result.int_len > k) {        result.int_len -= k;    } else {        for (i = result.digit_len - 1; i >= 0; i--)            result.digit[i + k] = result.digit[i];        for (i = 0; i < k; i++)            result.digit[i] = 0;        result.digit_len += k;	    }    result.sign *= b.sign;    return remove_zeros(result);}

/* Add, del, test parser */static ip_set_ip_tadt_parser(unsigned cmd, const char *optarg, void *data){	struct ip_set_req_nethash *mydata =	    (struct ip_set_req_nethash *) data;	char *saved = ipset_strdup(optarg);	char *ptr, *tmp = saved;	ip_set_ip_t cidr;	ptr = strsep(&tmp, "/");		if (tmp == NULL) {		if (cmd == CMD_TEST)			cidr = 32;		else			exit_error(PARAMETER_PROBLEM,				   "Missing cidr from `%s'", optarg);	} else		if (string_to_number(tmp, 1, 31, &cidr))			exit_error(PARAMETER_PROBLEM,				   "Out of range cidr `%s' specified", optarg);		mydata->cidr = cidr;	parse_ip(ptr, &mydata->ip);	if (!mydata->ip)		exit_error(PARAMETER_PROBLEM,			  "Zero valued IP address `%s' specified", ptr);	free(saved);	return mydata->ip;	};

static voidparse_tos(const char *s, struct ipt_tos_info *info){	unsigned int i;	unsigned int tos;	if (string_to_number(s, 0, 255, &tos) != -1) {				/* start IP precedence and TOS remark by f00110348 */		/*		if (tos == IPTOS_LOWDELAY		    || tos == IPTOS_THROUGHPUT		    || tos == IPTOS_RELIABILITY		    || tos == IPTOS_MINCOST		    || tos == IPTOS_NORMALSVC) {*/		 if ((tos >= 0) && (tos <= 255)) {		/* end IP precedence and TOS remark by f00110348 */				    	info->tos = (u_int8_t )tos;		    	return;		}	} else {		for (i = 0; i<sizeof(TOS_values)/sizeof(struct TOS_value); i++)			if (strcasecmp(s,TOS_values[i].name) == 0) {				info->tos = TOS_values[i].TOS;				return;			}	}	exit_error(PARAMETER_PROBLEM, "Bad TOS value `%s'", s);}

static struct in_addr *parse_mask(char *mask){	static struct in_addr maskaddr;	struct in_addr *addrp;	unsigned int bits;	if (mask == NULL) {		/* no mask at all defaults to 32 bits */		maskaddr.s_addr = 0xFFFFFFFF;		return &maskaddr;	}	if ((addrp = dotted_to_addr(mask)) != NULL)		/* dotted_to_addr already returns a network byte order addr */		return addrp;	if (string_to_number(mask, 0, 32, &bits) == -1)		xtables_error(PARAMETER_PROBLEM,			      "invalid mask `%s' specified", mask);	if (bits != 0) {		maskaddr.s_addr = htonl(0xFFFFFFFF << (32 - bits));		return &maskaddr;	}	maskaddr.s_addr = 0L;	return &maskaddr;}

static struct in6_addr *parse_ip6_mask(char *mask){	static struct in6_addr maskaddr;	struct in6_addr *addrp;	unsigned int bits;	if (mask == NULL) {				memset(&maskaddr, 0xff, sizeof maskaddr);		return &maskaddr;	}	if ((addrp = numeric_to_addr(mask)) != NULL)		return addrp;	if (string_to_number(mask, 0, 128, &bits) == -1)		ebt_print_error("Invalid IPv6 Mask '%s' specified", mask);	if (bits != 0) {		char *p = (char *)&maskaddr;		memset(p, 0xff, bits / 8);		memset(p + (bits / 8) + 1, 0, (128 - bits) / 8);		p[bits / 8] = 0xff << (8 - (bits & 7));		return &maskaddr;	}	memset(&maskaddr, 0, sizeof maskaddr);	return &maskaddr;}

/* * Get IP address and port from the argument. * Return 0 if failed, *	  1 if addr read *        2 if addr and port read */intparse_addrport(char *buf, u_int16_t proto, u_int32_t * addr,	       u_int16_t * port){	char *pp;	long prt;	struct in_addr inaddr;	pp = strchr(buf, ':');	if (pp)		*pp = '/0';	if (inet_aton(buf, &inaddr) != 0)		*addr = inaddr.s_addr;	else if (host_to_addr(buf, &inaddr) != -1)		*addr = inaddr.s_addr;	else		return 0;	if (pp == NULL)		return 1;	if ((prt = string_to_number(pp + 1, 0, 65535)) != -1)		*port = htons(prt);	else if ((prt = service_to_port(pp + 1, proto)) != -1)		*port = htons(prt);	else		return 0;	return 2;}

/* Function which parses command options; returns true if it   ate an option */static intparse(int c, char **argv, int invert, unsigned int *flags,      const struct ipt_entry *entry,      unsigned int *nfcache,      struct ipt_entry_match **match){	struct ipt_rateinfo *r = (struct ipt_rateinfo *)(*match)->data;	unsigned int num;	switch(c) {	case '%':		if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;		if (!parse_rate(optarg, &r->avg))			exit_error(PARAMETER_PROBLEM,				   "bad rate `%s'", optarg);		break;	case '$':		if (check_inverse(argv[optind-1], &invert, &optind, 0)) break;		if (string_to_number(optarg, 0, 10000, &num) == -1)			exit_error(PARAMETER_PROBLEM,				   "bad --limit-burst `%s'", optarg);		r->burst = num;		break;	default:		return 0;	}	if (invert)		exit_error(PARAMETER_PROBLEM,			   "limit does not support invert");	return 1;}

/**  *  @brief genevt proc write function * *  @param f	   file pointer *  @param buf     pointer to data buffer *  @param cnt     data number to write *  @param data    data to write *  @return 	   number of data */static intwlan_genevt_write(struct file *f, const char *buf, unsigned long cnt,                  void *data){    struct net_device *netdev = data;    wlan_private *priv = netdev->priv;    char databuf[10];    int genevt;    MODULE_GET;    if (cnt > 10) {        MODULE_PUT;        return cnt;    }    if (copy_from_user(databuf, buf, cnt)) {        MODULE_PUT;        return 0;    }    genevt = string_to_number(databuf);    switch (genevt) {    case GEN_FATAL_ERROR_EVT:        PRINTM(MSG, "proc: call wlan_fatal_error_handle/n");        wlan_fatal_error_handle(priv);        break;    default:        break;    }    MODULE_PUT;    return cnt;}

static int parse(int c, char **argv, int argc,      const struct ebt_u_entry *entry,      unsigned int *flags,      struct ebt_entry_match **match){	struct ebt_limit_info *r = (struct ebt_limit_info *)(*match)->data;	unsigned int num;	switch(c) {	case ARG_LIMIT:		ebt_check_option2(flags, FLAG_LIMIT);		if (ebt_check_inverse2(optarg))			ebt_print_error2("Unexpected `!' after --limit");		if (!parse_rate(optarg, &r->avg))			ebt_print_error2("bad rate `%s'", optarg);		break;	case ARG_LIMIT_BURST:		ebt_check_option2(flags, FLAG_LIMIT_BURST);		if (ebt_check_inverse2(optarg))			ebt_print_error2("Unexpected `!' after --limit-burst");		if (string_to_number(optarg, 0, 10000, &num) == -1)			ebt_print_error2("bad --limit-burst `%s'", optarg);		r->burst = num;		break;	default:		return 0;	}	return 1;}

/** *  @brief This function handle the generic file close * *  @param inode   A pointer to inode structure *  @param file    A pointer to file structure *  @return		N/A */static voidproc_on_close(struct inode *inode, struct file *file){#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 10, 0)	struct proc_private_data *priv = PDE_DATA(inode);#else	struct proc_private_data *priv = PDE(inode)->data;#endif	struct proc_data *pdata = file->private_data;	char *line;	int i;	ENTER();	if (!pdata->wrlen)		return;	line = pdata->wrbuf;	while (line[0]) {		for (i = 0; i < priv->num_items; i++) {			if (!strncmp			    (line, priv->pdata[i].name,			     strlen(priv->pdata[i].name))) {				line += strlen(priv->pdata[i].name) + 1;				if (priv->pdata[i].size == 1)					*((u8 *)priv->pdata[i].addr) =						(u8)string_to_number(line);				else if (priv->pdata[i].size == 2)					*((u16 *) priv->pdata[i].addr) =						(u16) string_to_number(line);				else if (priv->pdata[i].size == 4)					*((u32 *)priv->pdata[i].addr) =						(u32)string_to_number(line);			}		}		while (line[0] && line[0] != '/n')			line++;		if (line[0])			line++;	}	if (priv->pbt->bt_dev.hscmd || priv->pbt->bt_dev.pscmd	    || priv->pbt->bt_dev.sdio_pull_ctrl	    || priv->pbt->bt_dev.test_mode || priv->pbt->bt_dev.hscfgcmd) {		bt_prepare_command(priv->pbt);		wake_up_interruptible(&priv->pbt->MainThread.waitQ);	}	LEAVE();	return;}

static int parse(int c, char **argv, int invert, unsigned int *flags,		const struct ip6t_entry *entry,		struct ip6t_entry_target **target){	struct ip6t_HL_info *info = (struct ip6t_HL_info *) (*target)->data;	unsigned int value;	if (*flags & IP6T_HL_USED) {		exit_error(PARAMETER_PROBLEM, 				"Can't specify HL option twice");	}	if (!optarg) 		exit_error(PARAMETER_PROBLEM, 				"HL: You must specify a value");	if (check_inverse(optarg, &invert, NULL, 0))		exit_error(PARAMETER_PROBLEM,				"HL: unexpected `!'");		if (string_to_number(optarg, 0, 255, &value) == -1)			exit_error(PARAMETER_PROBLEM,			           "HL: Expected value between 0 and 255");	switch (c) {		case '1':			info->mode = IP6T_HL_SET;			break;		case '2':			if (value == 0) {				exit_error(PARAMETER_PROBLEM,					"HL: decreasing by 0?");			}			info->mode = IP6T_HL_DEC;			break;		case '3':			if (value == 0) {				exit_error(PARAMETER_PROBLEM,					"HL: increasing by 0?");			}			info->mode = IP6T_HL_INC;			break;		default:			return 0;	}		info->hop_limit = value;	*flags |= IP6T_HL_USED;	return 1;}

bool expand_data(const std::string s, void **d, unsigned *siz){std::string buf; unsigned tam,t,f,g,len,sl,r=0,pos; bool err; char c[2];	if (!bracketed_substr(s,buf,'(',')' ,&g)) return(false);	string_to_number(buf,tam);	if (siz!=0) *siz=tam;	if (tam==0)	{		*d=0;		return(true);	}	*d=new char[tam];	pos=0;	len=(unsigned)s.length();	for (f=g; f<len; f++) if (s[f]=='/n') break;	if (f>=len) return(false);	f+=2;	t=0;	c[1]=0;	err=false;	while ((r<tam)&&(f<len))	{		while ((f<len)&&(s[f]=='/t')) f++;		if (f<len)		{			g=f;			while ((g<len)&&(s[g]!='/n')) g++;			if (g<len)			{				buf=s.substr(f,g-f);				sl=(unsigned)buf.length();				for (unsigned h=0; h<sl; h+=2)				{					c[0]=read_hexbyte(buf[h],buf[h+1]);					if (!err)					{						r++;						((unsigned char *)(*d))[pos]=c[0];						pos++;					}				}				if (!err) f=g+1;			}			else			{				f=len;				err=true;			}		}		else err=true;	}	if (err) return(false);	return(true);}

std::string expand_str(const std::string &s){std::string res,buf; unsigned tam,t,f,g,len,sl,r=0; bool err; char c[2];	if (!bracketed_substr(s,buf,'(',')')) return(res);	string_to_number(buf,tam);	len=(unsigned)s.length();	for (f=0; f<len; f++) if (s[f]=='/n') break;	if (f>=len) return(res);	f+=2;	t=0;	c[1]=0;	err=false;	while ((r<tam)&&(f<len))	{		while ((f<len)&&(s[f]=='/t')) f++;		if (f<len)		{			g=f;			while ((g<len)&&(s[g]!='/n')) g++;			if (g<len)			{				buf=s.substr(f,g-f);				sl=(unsigned)buf.length();				for (unsigned h=0; h<sl; h+=2)				{					if (buf[h]!='*') c[0]=read_hexbyte(buf[h],buf[h+1]);					else					{						if (h+4>=sl) err=true;						else						{							c[0]=read_hexword(buf[h+1],buf[h+2],buf[h+3],buf[h+4]);							h+=3;						}					}					if (!err)					{						r++;						res+=c;					}				}				if (!err) f=g+1;			}			else			{				f=len;				err=true;			}		}		else err=true;	}	if (err) return("");	return(res);}

static int parse_service(char *buf, ipvs_service_t *svc){  char *portp = NULL;  long portn;  int result=SERVICE_NONE;  struct in_addr inaddr;  struct in6_addr inaddr6;  if (buf == NULL || str_is_digit(buf))    return SERVICE_NONE;  if (buf[0] == '[') {    buf++;    portp = strchr(buf, ']');    if (portp == NULL)      return SERVICE_NONE;    *portp = '/0';    portp++;    if (*portp == ':')      *portp = '/0';    else      return SERVICE_NONE;  }  if (inet_pton(AF_INET6, buf, &inaddr6) > 0) {    svc->addr.in6 = inaddr6;    svc->af = AF_INET6;    svc->netmask = 128;  } else {    portp = strrchr(buf, ':');    if (portp != NULL)      *portp = '/0';    if (inet_aton(buf, &inaddr) != 0) {      svc->addr.ip = inaddr.s_addr;      svc->af = AF_INET;    } else if (host_to_addr(buf, &inaddr) != -1) {      svc->addr.ip = inaddr.s_addr;      svc->af = AF_INET;    } else      return SERVICE_NONE;  }  result |= SERVICE_ADDR;  if (portp != NULL) {    result |= SERVICE_PORT;    if ((portn = string_to_number(portp+1, 0, 65535)) != -1)      svc->port = htons(portn);    else if ((portn = service_to_port(portp+1, svc->protocol)) != -1)      svc->port = htons(portn);    else      return SERVICE_NONE;  }  return result;}

static voidparse_tcp_option(const char *option, u_int8_t *result){	unsigned int ret;	if (string_to_number(option, 1, 255, &ret) == -1)		exit_error(PARAMETER_PROBLEM, "Bad TCP option `%s'", option);	*result = (u_int8_t)ret;}