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

irom app_action_t application_function_ota_finish(const string_t *src, string_t *dst){	static uint8_t md5_result[16];	string_new(static, local_md5_string, 34);	string_new(static, remote_md5_string, 34);	app_action_t action;	if((ota_state != state_write) && (ota_state != state_verify))	{		string_cat(dst, "OTA: not active/n");		ota_state = state_inactive;		return(app_action_error);	}	string_clear(&remote_md5_string);	if((parse_string(1, src, &remote_md5_string)) != parse_ok)	{		string_copy(dst, "OTA: missing md5sum string/n");		ota_state = state_inactive;		return(app_action_error);	}	if((string_length(&buffer_4k) > 0) &&			((action = flash_write_verify(src, dst)) != app_action_normal))	{		ota_state = state_inactive;		return(action);	}	if(remote_file_length != received)	{		string_format(dst, "OTA: file size differs: %u != %u/n", remote_file_length, received);		ota_state = state_inactive;		return(app_action_error);	}	string_clear(&local_md5_string);	MD5Final(md5_result, &md5);	string_bin_to_hex(&local_md5_string, md5_result, 16);	string_clear(dst);	if(!string_match_string(&local_md5_string, &remote_md5_string))	{		string_format(dst, "OTA: invalid md5sum: /"%s/" != /"%s/"/n",				string_to_const_ptr(&local_md5_string), string_to_ptr(&remote_md5_string));		ota_state = state_inactive;		return(app_action_error);	}	string_format(dst, "%s %s %s %d %d/n", ota_state == state_verify ? "VERIFY_OK" : "WRITE_OK",			string_to_const_ptr(&local_md5_string),			string_to_const_ptr(&remote_md5_string),			written, skipped);	ota_state = state_successful;	return(app_action_normal);}

irom static app_action_t application_function_wlan_ap_configure(const string_t *src, string_t *dst){	string_clear(&ssid);	string_clear(&passwd);	int channel;	if((parse_string(1, src, &ssid) == parse_ok) && (parse_string(2, src, &passwd) == parse_ok) &&			(parse_int(3, src, &channel, 0) == parse_ok))	{		if((channel < 1) || (channel > 13))		{			string_format(dst, "wlan-ap-configure: channel %d out of range (1-13)/n", channel);			return(app_action_error);		}		if(string_length(&passwd) < 8)		{			string_format(dst, "wlan-ap-configure: passwd /"%s/" too short (length must be >= 8)/n",					string_to_ptr(&passwd));			return(app_action_error);		}		strlcpy(config.ap_wlan.ssid, string_to_const_ptr(&ssid), sizeof(config.ap_wlan.ssid));		strlcpy(config.ap_wlan.passwd, string_to_const_ptr(&passwd), sizeof(config.ap_wlan.passwd));		config.ap_wlan.channel = channel;	}	string_format(dst, "wlan-ap-configure: ssid: /"%s/", passwd: /"%s/", channel: %d/n",			config.ap_wlan.ssid, config.ap_wlan.passwd, config.ap_wlan.channel);	return(app_action_normal);}

void dolines(SQLHSTMT *stmt, SQLSMALLINT ncol, char format){	int j;	long ans;	string *str, *tstr;	char istr[256];	long sb = 0;	SQLLEN si;	str = new_string();	tstr = new_string();	for(;;)	{		ans = SQLFetch(*stmt);		/*		 * I assume error here is EOF...		 */		if((ans != SQL_SUCCESS) && ( ans != SQL_SUCCESS_WITH_INFO))			break;		for(j=0;j<ncol;j++)		{			si = 0;			for(;;)			{				ans = SQLGetData(stmt, j+1, SQL_C_CHAR, istr, 256, &si);				if(ans == SQL_NO_DATA) break;				if(si == SQL_NO_TOTAL)				{					sb += 255;					}				else				{					sb += si;				}				string_cat(tstr, istr);						if(si != SQL_NO_TOTAL) break;			}			dolitem(str, string_s(tstr), (j == ncol - 1), format);			string_clear(tstr);		}		string_cat_c(str, '/n');		if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;		string_clear(str);	}	string_delete(str);	string_delete(tstr);	return;}

/* * input : uname(STR) aname(STR) * return: NORMAL * reply : NULL */static NEOERR* aic_cmd_appuserin(struct queue_entry *q, struct cache *cd, mdb_conn *db){    STRING str; string_init(&str);    char *aname, *uname;    int aid, uid;    NEOERR *err;    REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);    REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname);    aid = hash_string(aname);    uid = hash_string(uname);    hdf_set_int_value(q->hdfrcv, "uid", uid);    hdf_set_int_value(q->hdfrcv, "aid", aid);    err = aic_cmd_appusers(q, cd, db);    if (err != STATUS_OK) return nerr_pass(err);    if (hdf_get_valuef(q->hdfsnd, "userlist.%s.uname", uname))        return STATUS_OK;    err = mcs_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.userinfo"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(db, NULL, "INSERT INTO userinfo %s", NULL, str.buf);    string_clear(&str);        cache_delf(cd, PREFIX_USERLIST"%d", aid);    return STATUS_OK;}

static NEOERR* aux_cmd_inboxadd(struct aux_entry *e, QueueEntry *q){    STRING str; string_init(&str);    NEOERR *err;    mdb_conn *db = e->db;    HDF *node = hdf_get_child(q->hdfrcv, "mmid");insert:    if (node) hdf_set_value(q->hdfrcv, "mid", hdf_obj_value(node));        err = mdb_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.inbox"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "INSERT INTO inbox %s", NULL, str.buf);    string_clear(&str);    if (node) {        node = hdf_obj_next(node);        if (node) goto insert;    }    return STATUS_OK;}

static NEOERR* aux_cmd_emailadd(struct aux_entry *e, QueueEntry *q){    STRING str; string_init(&str);    char sum[LEN_MD5], *content;    NEOERR *err;    mdb_conn *db = e->db;    REQ_GET_PARAM_STR(q->hdfrcv, "content", content);        mstr_md5_str(content, sum);    hdf_set_value(q->hdfrcv, "checksum", sum);    HDF *node = hdf_get_child(q->hdfrcv, "mto");insert:    if (node) hdf_set_value(q->hdfrcv, "to", hdf_obj_value(node));        err = mdb_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.email"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "INSERT INTO email %s", NULL, str.buf);    string_clear(&str);    if (node) {        node = hdf_obj_next(node);        if (node) goto insert;    }    return STATUS_OK;}

static NEOERR* aux_cmd_cmtadd(struct aux_entry *e, QueueEntry *q){	STRING str; string_init(&str);    int type, oid;    NEOERR *err;    REQ_GET_PARAM_INT(q->hdfrcv, "type", type);    REQ_GET_PARAM_INT(q->hdfrcv, "oid", oid);    mdb_conn *db = e->db;    struct cache *cd = e->cd;    err = mdb_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.comment"),                          &str);	if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "INSERT INTO comment %s", NULL, str.buf);        string_clear(&str);        cache_delf(cd, PREFIX_COMMENT"%d:%d_0", type, oid);        return STATUS_OK;}

NEOERR* system_who_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses){    STRING str; string_init(&str);    mdb_conn *db = hash_lookup(dbh, "trace");    char *mname;    NEOERR *err;    MCS_NOT_NULLB(cgi->hdf, db);        MEMBER_CHECK_ADMIN();    SET_DASHBOARD_ACTION(cgi->hdf);    hdf_set_int_value(cgi->hdf, PRE_QUERY".type", TRACE_TYPE_PAGEVIEW);    err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),                              hdf_get_obj(g_cfg, "Db.QueryCond.system.who"),                              &str, NULL);    if (err != STATUS_OK) return nerr_pass(err);    MDB_QUERY_RAW(db, "emap", _COL_EMAP_WHO,                  " %s GROUP BY sender ORDER BY min(intime) DESC LIMIT 100",                  NULL, str.buf);    err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_WHO, PRE_OUTPUT".who",                       NULL, MDB_FLAG_EMPTY_OK);    if (err != STATUS_OK) return nerr_pass(err);    string_clear(&str);    hdf_set_attr(cgi->hdf, PRE_OUTPUT".who", "type", "array");    return STATUS_OK;}

NEOERR* system_view_detail_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses){    STRING str; string_init(&str);    mdb_conn *db = hash_lookup(dbh, "trace");    char *mname;    NEOERR *err;    MCS_NOT_NULLB(cgi->hdf, db);        MEMBER_CHECK_ADMIN();    SET_DASHBOARD_ACTION(cgi->hdf);    err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),                              hdf_get_obj(g_cfg, "Db.QueryCond.system.viewdetail"),                              &str, NULL);    if (err != STATUS_OK) return nerr_pass(err);    MDB_QUERY_RAW(db, "emap", _COL_EMAP_VIEW_DETAIL,                  " %s ORDER BY intime LIMIT 100", NULL, str.buf);    err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_VIEW_DETAIL, PRE_OUTPUT".details",                       NULL, MDB_FLAG_EMPTY_OK);    if (err != STATUS_OK) return nerr_pass(err);    string_clear(&str);    hdf_set_attr(cgi->hdf, PRE_OUTPUT".details", "type", "array");    return STATUS_OK;}

void save_dialog_ok(char *filename){/*	gtk_widget_set_sensitive(GTK_WIDGET(file_selection), 0);		while(gtk_events_pending())		gtk_main_iteration_do(0);*/		stop_working();		int r = 0;		if(!map_filename->text[0])		r = 1;	string_clear(map_filename);	char *cc = filename;			while(*cc && *cc != '.')		string_cat_char(map_filename, *cc++);	string_cat_text(map_filename, ".map");	set_map_path();		if(r)		make_wall_texture_paths_relative();		map_save();		start_working();}

void set_map_path(){	string_clear(map_path);		// count how many '/'s are in map_filename		int slashes = 0;	char *cc = map_filename->text;		while(*cc)	{		if(*cc++ == '/')			slashes++;	}		cc = map_filename->text;		while(slashes)	{		string_cat_char(map_path, *cc);				if(*cc++ == '/')			slashes--;	}}

void lerr_opfinish_json(NEOERR *err, HDF *hdf){    if (err == STATUS_OK) {        hdf_set_value(hdf, PRE_SUCCESS, "1");        return;    }        hdf_remove_tree(hdf, PRE_SUCCESS);        char buf[1024], errname[128];    NEOERR *neede = mcs_err_valid(err);    if (!neede) neede = err;    snprintf(buf, sizeof(buf), "%s:%d %s",             neede->file, neede->lineno,             _lookup_errname(neede, errname, sizeof(errname)));    /* set PRE_ERRXXX with the most recently err */    if (!hdf_get_obj(hdf, PRE_ERRMSG)) {        hdf_set_value(hdf, PRE_ERRMSG, buf);    }    hdf_set_int_value(hdf, PRE_ERRCODE, neede->error);    STRING str; string_init(&str);    nerr_error_traceback(err, &str);    mtc_err("%s", str.buf);    hdf_set_value(hdf, PRE_ERRTRACE, str.buf);    nerr_ignore(&err);    string_clear(&str);}

void lerr_opfinish_json(NEOERR *err, HDF *hdf){    if (err == STATUS_OK) {        hdf_set_value(hdf, PRE_SUCCESS, "1");        mcs_set_int_attr(hdf, PRE_SUCCESS, "type", CNODE_TYPE_INT);        return;    }    hdf_remove_tree(hdf, PRE_SUCCESS);    NEOERR *neede = mcs_err_valid(err);    /* set PRE_ERRXXX with the most recently err */    mcs_set_int_value_with_type(hdf, PRE_ERRCODE, neede->error, CNODE_TYPE_INT);    if (!hdf_get_obj(hdf, PRE_ERRMSG)) {        hdf_set_valuef(hdf, "%s=%s:%d %s",                       PRE_ERRMSG, neede->file, neede->lineno, neede->desc);    }    STRING str; string_init(&str);    nerr_error_traceback(err, &str);    mtc_err("%s", str.buf);    hdf_set_value(hdf, PRE_ERRTRACE, str.buf);    nerr_ignore(&err);    string_clear(&str);}

void dolines(PGresult *pgr, char format){	int i, j, ncol = 0, nrow = 0;	string *str;	char *s;	nrow = PQntuples(pgr);	ncol = PQnfields(pgr);	str = new_string();	for(i=0;i<nrow;i++)	{		for(j=0;j<ncol;j++)		{			s = PQgetvalue(pgr, i, j);			dolitem(str, s, (j == ncol - 1), format);		}		string_cat_c(str, '/n');		if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;		string_clear(str);	}	string_delete(str);	return;}

void dolines(MYSQL_RES *res, char format){	int j;	unsigned int ncol = 0;	string *str;	char *s;	MYSQL_ROW row;	ncol = mysql_num_fields(res);	str = new_string();	while((row = mysql_fetch_row(res)) != NULL)	{		for(j=0;j<ncol;j++)		{			s = row[j];			dolitem(str, s, (j == ncol - 1), format);		}		string_cat_c(str, '/n');		if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;		string_clear(str);	}	string_delete(str);	return;}

static NEOERR* dyn_cmd_addtrack(struct queue_entry *q, struct cache *cd, mdb_conn *db){    STRING str; string_init(&str);    char *aname, *uname, *oname;    int aid, uid, oid = 0;    NEOERR *err;    REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname);    REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);    REQ_FETCH_PARAM_STR(q->hdfrcv, "oname", oname);    uid = hash_string(uname);    aid = hash_string(aname);    if (oname) oid = hash_string(oname);    hdf_set_int_value(q->hdfrcv, "aid", aid);    hdf_set_int_value(q->hdfrcv, "uid", uid);    hdf_set_int_value(q->hdfrcv, "oid", oid);        err = mcs_build_incol(q->hdfrcv,                          hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.track"),                          &str);    if (err != STATUS_OK) return nerr_pass(err);        MDB_EXEC(db, NULL, "INSERT INTO track %s", NULL, str.buf);    string_clear(&str);    return STATUS_OK;}

NEOERR* blog_data_mod(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses){    mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux");    mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");    char *aname;    int bid;    NEOERR *err;    LPRE_DBOP(cgi->hdf, conn);    HDF_GET_INT(cgi->hdf, PRE_QUERY".bid", bid);    APP_CHECK_LOGIN();        if (hdf_get_int_value(evt->hdfrcv, "state", 0) < LCS_ST_ADMIN)        return nerr_raise(LERR_LIMIT, "%s wan't be admin", aname);    STRING str;    string_init(&str);    err = mcs_build_upcol(hdf_get_obj(cgi->hdf, PRE_QUERY),                          hdf_get_obj(g_cfg, "Db.UpdateCol.blog"), &str);    if (err != STATUS_OK) return nerr_pass(err);    MDB_EXEC(conn, NULL, "UPDATE blog SET %s WHERE id=%d AND author=$1",             "s", str.buf, bid, aname);    string_clear(&str);    char command[1024];    snprintf(command, sizeof(command), PATH_PAGER"blg -b %d", bid);    mtc_dbg("%s", command);    system(command);    return STATUS_OK;}

/** * Get one line from specific stream with delimiter. */bool_t string_getline_delimiter(string_t* pstr_string, FILE* fp_stream, char c_delimiter){    int n_char = EOF;    assert(pstr_string != NULL);    assert(fp_stream != NULL);    if(c_delimiter == '/n')    {        return string_getline(pstr_string, fp_stream);    }    else    {        clearerr(fp_stream);        string_clear(pstr_string);        while(!feof(fp_stream) && !ferror(fp_stream) && (char)n_char != c_delimiter &&              string_size(pstr_string) < string_max_size(pstr_string))        {            n_char = fgetc(fp_stream);            if((char)n_char != c_delimiter && n_char != EOF)            {                string_push_back(pstr_string, (char)n_char);            }        }        if((char)n_char == c_delimiter)        {            return true;        }        else        {            return false;        }    }}

bool file_getLine(FILE *file, string_t *str){    string_clear(str);    bool v = file_readLine(file, str);    string_cstr(str);    return v;}

bool file_getLine_delim(FILE *file, string_t *str, char delim){    string_clear(str);    bool v = file_readLine_delim(file, str, delim);    string_cstr(str);    return v;}

NEOERR *hdf_write_string (HDF *hdf, char **s){  STRING str;  NEOERR *err;  *s = NULL;  string_init (&str);  err = hdf_dump_str (hdf, NULL, 1, &str);  if (err)  {    string_clear (&str);    return nerr_pass(err);  }  if (str.buf == NULL)  {    *s = strdup("");    if (*s == NULL) return nerr_raise(NERR_NOMEM, "Unable to allocate empty string");  }  else  {    *s = str.buf;  }  return STATUS_OK;}

irom static app_action_t application_function_wlan_client_configure(const string_t *src, string_t *dst){	string_clear(&ssid);	string_clear(&passwd);	if((parse_string(1, src, &ssid) == parse_ok) && (parse_string(2, src, &passwd) == parse_ok))	{		strlcpy(config.client_wlan.ssid, string_to_const_ptr(&ssid), sizeof(config.client_wlan.ssid));		strlcpy(config.client_wlan.passwd, string_to_const_ptr(&passwd), sizeof(config.client_wlan.passwd));	}	string_format(dst, "wlan-client-configure: ssid: /"%s/", passwd: /"%s/"/n",			config.client_wlan.ssid, config.client_wlan.passwd);	return(app_action_normal);}

void clear_map()		// always called when not working{	delete_all_nodes();	delete_all_conns();	delete_all_curves();	delete_all_points();	delete_all_fills();	delete_all_lines();	delete_all_tiles();	delete_all_objects();	map_saved = 1;	string_clear(map_filename);	string_clear(map_path);	char *cwd =  get_current_dir_name();	string_cat_text(map_path, cwd);	free(cwd);}

irom void config_dump(string_t *dst, const config_t *cfg){	string_new(static, ntp_server, 32);	string_clear(&ntp_server);	string_ip(&ntp_server, cfg->ntp.server);	string_format(dst, 			"> config magic: %04x/n"			"> config version: %d/n"			"> wlan client ssid: %s/n"			"> wlan client passwd: %s/n"			"> wlan ap ssid: %s/n"			"> wlan ap passwd: %s/n"			"> wlan ap channel: %d/n"			"> wlan mode: %s mode/n"			"> bridge tcp port: %u/n"			"> bridge tcp timeout: %u/n"			"> command tcp port: %u/n"			"> command tcp timeout: %u/n"			"> ntp server: %s/n"			"> ntp time zone: GMT%c%u/n"			"> display flip timeout: %u/n"			"> display default message: %s/n"			"> status trigger gpio (-1 is disabled): %d/%d/n"			"> wlan association trigger gpio (-1 is disabled): %d/%d/n"			"> flags: ", 		cfg->magic,		cfg->version,		cfg->client_wlan.ssid,		cfg->client_wlan.passwd,		cfg->ap_wlan.ssid,		cfg->ap_wlan.passwd,		cfg->ap_wlan.channel,		cfg->wlan_mode == config_wlan_mode_client ? "client" : "ap",		cfg->bridge.port,		cfg->bridge.timeout,		cfg->command.port,		cfg->command.timeout,		string_to_ptr(&ntp_server),		cfg->ntp.timezone >= 0 ? '+' : '-',		cfg->ntp.timezone >= 0 ? cfg->ntp.timezone : 0 - cfg->ntp.timezone,		cfg->display.flip_timeout,		cfg->display.default_msg,		cfg->status_trigger.io,		cfg->status_trigger.pin,		cfg->assoc_trigger.io,		cfg->assoc_trigger.pin);	config_flags_to_string(dst, 0, 0, cfg->flags);	string_cat(dst, "/n> uart: ");	uart_parameters_to_string(dst, &cfg->uart);	string_cat(dst, "/n> gpios:/n");	io_config_dump(dst, cfg, -1, -1, false);}

NEOERR * hdf_read_string (HDF *hdf, const char *str){  NEOERR *err;  int lineno = 0;  STRING line;  string_init(&line);  err = _hdf_read_string(hdf, &str, &line, "<string>", &lineno, INCLUDE_ERROR);  string_clear(&line);  return nerr_pass(err);}

irom static app_action_t flash_write_verify(const string_t *src, string_t *dst){	char *verify_buffer = string_to_ptr(dst);	char *write_buffer = string_to_ptr(&buffer_4k);	int write_buffer_length = string_length(&buffer_4k);	if(string_size(dst) < 0x1000)	{		string_format(dst, "OTA: string verify buffer too small: %d/n", string_size(dst));		return(app_action_error);	}	if(ota_state == state_write)	{		spi_flash_read(flash_sector * 0x1000, (void *)verify_buffer, write_buffer_length);		if(ets_memcmp(write_buffer, verify_buffer, write_buffer_length))		{			spi_flash_erase_sector(flash_sector);			spi_flash_write(flash_sector * 0x1000, (void *)write_buffer, write_buffer_length);			written++;		}		else			skipped++;	}	spi_flash_read(flash_sector * 0x1000, (void *)verify_buffer, write_buffer_length);	MD5Update(&md5, verify_buffer, write_buffer_length);	if(ets_memcmp(write_buffer, verify_buffer, write_buffer_length))	{		string_copy(dst, "OTA: verify mismatch/n");		return(app_action_error);	}	flash_sector++;	received += write_buffer_length;	string_clear(&buffer_4k);	string_clear(dst);	return(app_action_normal);}

NEOERR * hdf_read_string_ignore (HDF *hdf, const char *str, int ignore){  NEOERR *err;  int lineno = 0;  STRING line;  string_init(&line);  err = _hdf_read_string(hdf, &str, &line, "<string>", &lineno,                         (ignore ? INCLUDE_IGNORE : INCLUDE_ERROR));  string_clear(&line);  return nerr_pass(err);}

extern char* file_read_line(xString *const line , FILE* fp){   char *result = NULL;      string_clear(line);   if ( NULL == fp )         error(FATAL, "NULL file pointer");   else{      boolean re_readline;      do {         char *const pLastChar = get_string_value(line) + get_string_size (line) -2;			fpos_t startOfLine;			fgetpos (fp, &startOfLine);			re_readline = FALSE;			*pLastChar = '/0';			result = fgets (get_string_value(line), (int) get_string_size(line), fp);			if (result == NULL)			{				if (! feof(fp))					error (FATAL | ERROR, "Failure on attempt to read file");			}			else if (*pLastChar != '/0'  &&					 *pLastChar != '/n'  &&  *pLastChar != '/r')			{				/*  buffer overflow */				re_readline = string_auto_resize(line);				if (re_readline)					fsetpos (fp, &startOfLine);				else					error (FATAL | ERROR, "input line too big; out of memory");			}			else			{				char* eol;            line->length = strlen (line->buffer);				/* canonicalize new line */				eol = get_string_value(line) + get_string_length(line) - 1;				if (*eol == '/r')					*eol = '/n';				else if (*(eol - 1) == '/r'  &&  *eol == '/n')				{					*(eol - 1) = '/n';					*eol = '/0';					--line->length;				}			}      }while(re_readline);   }   return result;}

static voidvpnconnect_plugin_string_list_item_free (struct vpnconnect_plugin_string_list *l){  if (l)    {      free (l->name);      string_clear (l->value);      free (l->value);      free (l);    }}