Llewellyn/conky
1
0
Fork 0
mirror of https://github.com/Llewellynvdm/conky.git synced 2024-12-28 13:00:45 +00:00
Code Issues Releases Activity

Use "using namespace std;" and remove all std::'s

Browse Source 
I'm doing this because otherwise i'll will forget to add all those
std::'s and will lose a LOT of time finding the problems.
If you don't agree, undo this patch...
...but i hope you won't :)
This commit is contained in:
Nikolas Garofil 2010-02-24 19:39:45 +01:00
parent 63133c19d6
commit 41e80b9833
23 changed files with 149 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/algebra.cc
View File

@ -259,7 +259,7 @@ int compare(const char *expr)
int check_if_match(struct text_object *obj)
{
std::unique_ptr<char []> expression(new char[max_user_text]);
unique_ptr<char []> expression(new char[max_user_text]);
int val;
int result = 1;

8
src/audacious.cc
View File

@ -75,7 +75,7 @@ void update_audacious(void)
}
}
std::lock_guard<std::mutex> lock(info.audacious.p_timed_thread->mutex());
lock_guard<mutex> lock(info.audacious.p_timed_thread->mutex());
memcpy(&info.audacious.items, audacious_items, sizeof(audacious_items));
}
@ -88,8 +88,8 @@ int create_audacious_thread(void)
{
if (!info.audacious.p_timed_thread) {
info.audacious.p_timed_thread =
timed_thread::create(std::bind(audacious_thread_func,
std::placeholders::_1), info.music_player_interval *
timed_thread::create(bind(audacious_thread_func,
placeholders::_1), info.music_player_interval *
1000000);
}
@ -237,7 +237,7 @@ void audacious_thread_func(thread_handle &handle)
} while (0);
{
/* Deliver the refreshed items array to audacious_items. */
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
memcpy(&audacious_items, items, sizeof(items));
}

12
src/ccurl_thread.cc
View File

@ -119,7 +119,7 @@ void ccurl_fetch_data(thread_handle &handle, ccurl_location_ptr &curloc)
long http_status_code;
if(curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_status_code) == CURLE_OK && http_status_code == 200) {
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
curloc->process_function(curloc->result, chunk.memory);
} else {
NORM_ERR("curl: no data from server");
@ -142,8 +142,8 @@ void ccurl_init_thread(ccurl_location_ptr curloc, int interval)
#ifdef DEBUG
assert(curloc->result);
#endif /* DEBUG */
curloc->p_timed_thread = timed_thread::create(std::bind(ccurl_thread,
std::placeholders::_1, curloc), interval * 1000000);
curloc->p_timed_thread = timed_thread::create(bind(ccurl_thread,
placeholders::_1, curloc), interval * 1000000);
if (!curloc->p_timed_thread) {
NORM_ERR("curl thread: error creating timed thread");
@ -194,8 +194,8 @@ void ccurl_process_info(char *p, int p_max_size, char *uri, int interval)
if (!curloc->p_timed_thread) {
curloc->result = (char*)malloc(max_user_text);
memset(curloc->result, 0, max_user_text);
curloc->process_function = std::bind(ccurl_parse_data,
std::placeholders::_1, std::placeholders::_2);
curloc->process_function = bind(ccurl_parse_data,
placeholders::_1, placeholders::_2);
ccurl_init_thread(curloc, interval);
if (!curloc->p_timed_thread) {
NORM_ERR("error setting up curl thread");
@ -203,7 +203,7 @@ void ccurl_process_info(char *p, int p_max_size, char *uri, int interval)
}
std::lock_guard<std::mutex> lock(curloc->p_timed_thread->mutex());
lock_guard<mutex> lock(curloc->p_timed_thread->mutex());
strncpy(p, curloc->result, p_max_size);
}

6
src/ccurl_thread.h
View File

@ -43,11 +43,11 @@ struct ccurl_location_t {
/* function to call when data is ready to be processed, the first argument
* will be the result pointer, and the second argument is an internal
* buffer that shouldn't be mangled */
std::function<void(char *, const char *)> process_function;
function<void(char *, const char *)> process_function;
};
typedef std::shared_ptr<ccurl_location_t> ccurl_location_ptr;
typedef std::list<ccurl_location_ptr> ccurl_location_list;
typedef shared_ptr<ccurl_location_t> ccurl_location_ptr;
typedef list<ccurl_location_ptr> ccurl_location_list;
/* find an existing location for the uri specified */
ccurl_location_ptr ccurl_find_location(ccurl_location_list &locations, char *uri);

2
src/combine.cc
View File

@ -96,7 +96,7 @@ void parse_combine_arg(struct text_object *obj, const char *arg, void *free_at_c
void print_combine(struct text_object *obj, char *p, int p_max_size)
{
struct combine_data *cd = (struct combine_data *)obj->data.opaque;
std::vector<std::vector<char>> buf;
vector<vector<char>> buf;
buf.resize(2);
buf[0].resize(max_user_text);
buf[1].resize(max_user_text);

8
src/common.cc
View File

@ -638,7 +638,7 @@ void print_evaluate(struct text_object *obj, char *p, int p_max_size)
int if_empty_iftest(struct text_object *obj)
{
std::vector<char> buf(max_user_text);
vector<char> buf(max_user_text);
int result = 1;
generate_text_internal(&(buf[0]), max_user_text, *obj->sub);
@ -769,7 +769,7 @@ void print_battery_short(struct text_object *obj, char *p, int p_max_size)
void print_blink(struct text_object *obj, char *p, int p_max_size)
{
//blinking like this can look a bit ugly if the chars in the font don't have the same width
std::vector<char> buf(max_user_text);
vector<char> buf(max_user_text);
static int visible = 1;
static int last_len = 0;
int i;
@ -788,7 +788,7 @@ void print_blink(struct text_object *obj, char *p, int p_max_size)
void print_include(struct text_object *obj, char *p, int p_max_size)
{
std::vector<char> buf(max_user_text);
vector<char> buf(max_user_text);
if (!obj->sub)
return;
@ -799,7 +799,7 @@ void print_include(struct text_object *obj, char *p, int p_max_size)
void print_to_bytes(struct text_object *obj, char *p, int p_max_size)
{
std::vector<char> buf(max_user_text);
vector<char> buf(max_user_text);
long long bytes;
char unit[16]; // 16 because we can also have long names (like mega-bytes)

2
src/conky.h
View File

@ -31,6 +31,8 @@
#ifndef _conky_h_
#define _conky_h_
using namespace std;
#include <config.h> /* defines */
#include "common.h" /* at least for struct dns_data */
#include <sys/utsname.h> /* struct uname_s */

2
src/diskio.cc
View File

@ -58,7 +58,7 @@ void clear_diskio_stats(void)
struct diskio_stat *prepare_diskio_stat(const char *s)
{
struct stat sb;
std::vector<char> stat_name(text_buffer_size), device_name(text_buffer_size);
vector<char> stat_name(text_buffer_size), device_name(text_buffer_size);
struct diskio_stat *cur = &stats;
if (!s)

8
src/exec.cc
View File

@ -162,7 +162,7 @@ static inline void read_exec(const char *data, char *buf, const int size)
length = fread(buf, 1, size, fp);
pclose(fp);
buf[std::min(length, size-1)] = '\0';
buf[min(length, size-1)] = '\0';
if (length > 0 && buf[length - 1] == '\n') {
buf[length - 1] = '\0';
}
@ -203,7 +203,7 @@ static void threaded_exec(thread_handle &handle, struct text_object *obj)
}
{
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
free_and_zero(ed->buffer);
ed->buffer = buff;
}
@ -323,13 +323,13 @@ void print_execi(struct text_object *obj, char *p, int p_max_size)
* note that we don't register this thread with the
* timed_thread list, because we destroy it manually
*/
ed->p_timed_thread = timed_thread::create(std::bind(threaded_exec, std::placeholders::_1, obj), ed->interval * 1000000, false);
ed->p_timed_thread = timed_thread::create(bind(threaded_exec, placeholders::_1, obj), ed->interval * 1000000, false);
if (!ed->p_timed_thread) {
NORM_ERR("Error creating texeci timed thread");
}
fillbuffer = false;
} else {
std::lock_guard<std::mutex> lock(ed->p_timed_thread->mutex());
lock_guard<mutex> lock(ed->p_timed_thread->mutex());
}
} else {
if (time_to_update(ed)) {

55
src/libtcp-portmon.cc
View File

@ -26,6 +26,7 @@
#include <config.h>
#endif
#include "conky.h"
#include "libtcp-portmon.h"
#include <cstdio>
@ -75,8 +76,8 @@ namespace {
bool operator==(const tcp_connection_t &a, const tcp_connection_t &b)
{
return a.local_port == b.local_port && a.remote_port == b.remote_port &&
! std::memcmp(&a.local_addr, &b.local_addr, sizeof(a.local_addr)) &&
! std::memcmp(&a.remote_addr.s6_addr, &b.remote_addr, sizeof(a.remote_addr));
! memcmp(&a.local_addr, &b.local_addr, sizeof(a.local_addr)) &&
! memcmp(&a.remote_addr.s6_addr, &b.remote_addr, sizeof(a.remote_addr));
}
/* ------------------------------------------------------------------------
@ -85,10 +86,10 @@ namespace {
* The second parameter provides the mechanism for removing connections if
* they are not seen again in subsequent update cycles.
* ------------------------------------------------------------------------ */
typedef std::unordered_map<tcp_connection_t, int, tcp_connection_hash> connection_hash_t;
typedef unordered_map<tcp_connection_t, int, tcp_connection_hash> connection_hash_t;
/* start and end of port monitor range. Set start=end to monitor a single port */
typedef std::pair<in_port_t, in_port_t> port_range_t;
typedef pair<in_port_t, in_port_t> port_range_t;
/* hash function for port ranges */
struct port_range_hash {
@ -98,7 +99,7 @@ namespace {
}
};
typedef std::unordered_map<port_range_t,
typedef unordered_map<port_range_t,
tcp_port_monitor_t,
port_range_hash> monitor_hash_t;
@ -112,7 +113,7 @@ struct _tcp_port_monitor_t {
connection_hash_t hash;
/* array of connection pointers for O(1) peeking
* these point into the hash table*/
std::vector<const tcp_connection_t *> p_peek;
vector<const tcp_connection_t *> p_peek;
_tcp_port_monitor_t(int max_connections)
: hash(), p_peek(max_connections, static_cast<const tcp_connection_t *>(NULL))
@ -132,7 +133,7 @@ struct _tcp_port_monitor_t {
* done in O(1) time instead of O(n) time for each peek. */
/* zero out the peek array */
std::fill(p_peek.begin(), p_peek.end(), static_cast<tcp_connection_t *>(NULL));
fill(p_peek.begin(), p_peek.end(), static_cast<tcp_connection_t *>(NULL));
size_t i = 0;
for (connection_hash_t::iterator j = hash.begin(); j != hash.end(); ++j, ++i ) {
@ -275,7 +276,7 @@ namespace {
/* checks whether the address is a IPv4-mapped IPv6 address */
bool is_4on6(const struct in6_addr *addr)
{
return ! std::memcmp(&addr->s6_addr, prefix_4on6, sizeof(prefix_4on6));
return ! memcmp(&addr->s6_addr, prefix_4on6, sizeof(prefix_4on6));
}
@ -285,15 +286,15 @@ namespace {
union sockaddr_in46 sa;
socklen_t slen;
std::memset(&sa, 0, sizeof(sa));
memset(&sa, 0, sizeof(sa));
if(is_4on6(addr)) {
sa.sa4.sin_family = AF_INET;
std::memcpy(&sa.sa4.sin_addr.s_addr, &addr->s6_addr[12], 4);
memcpy(&sa.sa4.sin_addr.s_addr, &addr->s6_addr[12], 4);
slen = sizeof(sa.sa4);
} else {
sa.sa6.sin6_family = AF_INET6;
std::memcpy(&sa.sa6.sin6_addr, addr, sizeof(struct in6_addr));
memcpy(&sa.sa6.sin6_addr, addr, sizeof(struct in6_addr));
slen = sizeof(sa.sa6);
}
@ -305,48 +306,48 @@ namespace {
{
size_t i;
if(std::strlen(p_buffer) < 32) { //IPv4 address
if(strlen(p_buffer) < 32) { //IPv4 address
i = sizeof(prefix_4on6);
std::memcpy(addr->s6_addr, prefix_4on6, i);
memcpy(addr->s6_addr, prefix_4on6, i);
} else {
i = 0;
}
for( ; i < sizeof(addr->s6_addr); i+=4, p_buffer+=8) {
std::sscanf(p_buffer, "%8x", (unsigned *)&addr->s6_addr[i]);
sscanf(p_buffer, "%8x", (unsigned *)&addr->s6_addr[i]);
}
}
/* adds connections from file to the collection */
void process_file(tcp_port_monitor_collection_t *p_collection, const char *file)
{
std::FILE *fp;
FILE *fp;
char buf[256];
char local_addr[40];
char remote_addr[40];
tcp_connection_t conn;
unsigned long inode, uid, state;
if ((fp = std::fopen(file, "r")) == NULL) {
if ((fp = fopen(file, "r")) == NULL) {
return;
}
/* ignore field name line */
if(std::fgets(buf, 255, fp) == NULL) {
std::fclose(fp);
if(fgets(buf, 255, fp) == NULL) {
fclose(fp);
return;
}
/* read all tcp connections */
while (std::fgets(buf, sizeof(buf), fp) != NULL) {
while (fgets(buf, sizeof(buf), fp) != NULL) {
if (std::sscanf(buf,
if (sscanf(buf,
"%*d: %39[0-9a-fA-F]:%hx %39[0-9a-fA-F]:%hx %lx %*x:%*x %*x:%*x %*x %lu %*d %lu",
local_addr, &conn.local_port,
remote_addr, &conn.remote_port,
(unsigned long *) &state, (unsigned long *) &uid,
(unsigned long *) &inode) != 7) {
std::fprintf(stderr, "%s: bad file format\n", file);
fprintf(stderr, "%s: bad file format\n", file);
}
/** TCP_ESTABLISHED equals 1, but is not (always??) included **/
//if ((inode == 0) || (state != TCP_ESTABLISHED)) {
@ -362,7 +363,7 @@ namespace {
&show_connection_to_tcp_port_monitor, (void *) &conn);
}
std::fclose(fp);
fclose(fp);
}
}
@ -389,8 +390,8 @@ int peek_tcp_port_monitor(const tcp_port_monitor_t *p_monitor, int item,
return -1;
}
std::memset(p_buffer, 0, buffer_size);
std::memset(&sa, 0, sizeof(sa));
memset(p_buffer, 0, buffer_size);
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
@ -404,7 +405,7 @@ int peek_tcp_port_monitor(const tcp_port_monitor_t *p_monitor, int item,
case COUNT:
std::snprintf(p_buffer, buffer_size, "%u", unsigned(p_monitor->hash.size()));
snprintf(p_buffer, buffer_size, "%u", unsigned(p_monitor->hash.size()));
break;
case REMOTEIP:
@ -419,7 +420,7 @@ int peek_tcp_port_monitor(const tcp_port_monitor_t *p_monitor, int item,
case REMOTEPORT:
std::snprintf(p_buffer, buffer_size, "%d",
snprintf(p_buffer, buffer_size, "%d",
p_monitor->p_peek[connection_index]->remote_port);
break;
@ -441,7 +442,7 @@ int peek_tcp_port_monitor(const tcp_port_monitor_t *p_monitor, int item,
case LOCALPORT:
std::snprintf(p_buffer, buffer_size, "%d",
snprintf(p_buffer, buffer_size, "%d",
p_monitor->p_peek[connection_index]->local_port);
break;

26
src/mail.cc
View File

@ -616,7 +616,7 @@ int imap_check_status(char *recvbuf, struct mail_s *mail, thread_handle &handle)
NORM_ERR("Error parsing IMAP response: %s", recvbuf);
return -1;
} else {
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
sscanf(reply, "MESSAGES %lu UNSEEN %lu", &mail->messages,
&mail->unseen);
}
@ -635,12 +635,12 @@ void imap_unseen_command(struct mail_s *mail, unsigned long old_unseen, unsigned
}
static void ensure_mail_thread(struct mail_s *mail,
const std::function<void(thread_handle &, struct mail_s *mail)> &func, const char *text)
const function<void(thread_handle &, struct mail_s *mail)> &func, const char *text)
{
if (mail->p_timed_thread)
return;
mail->p_timed_thread = timed_thread::create(std::bind(func, std::placeholders::_1, mail), mail->interval * 1000000);
mail->p_timed_thread = timed_thread::create(bind(func, placeholders::_1, mail), mail->interval * 1000000);
if (!mail->p_timed_thread) {
NORM_ERR("Error creating %s timed thread", text);
}
@ -832,7 +832,7 @@ static void imap_thread(thread_handle &handle, struct mail_s *mail)
buf--;
}
if (sscanf(buf, "* %lu EXISTS\r\n", &messages) == 1) {
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
if (mail->messages != messages) {
force_check = 1;
mail->messages = messages;
@ -947,10 +947,10 @@ void print_imap_unseen(struct text_object *obj, char *p, int p_max_size)
if (!mail)
return;
ensure_mail_thread(mail, std::bind(imap_thread, std::placeholders::_1, std::placeholders::_2), "imap");
ensure_mail_thread(mail, bind(imap_thread, placeholders::_1, placeholders::_2), "imap");
if (mail && mail->p_timed_thread) {
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
lock_guard<mutex> lock(mail->p_timed_thread->mutex());
snprintf(p, p_max_size, "%lu", mail->unseen);
}
}
@ -962,10 +962,10 @@ void print_imap_messages(struct text_object *obj, char *p, int p_max_size)
if (!mail)
return;
ensure_mail_thread(mail, std::bind(imap_thread, std::placeholders::_1, std::placeholders::_2), "imap");
ensure_mail_thread(mail, bind(imap_thread, placeholders::_1, placeholders::_2), "imap");
if (mail && mail->p_timed_thread) {
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
lock_guard<mutex> lock(mail->p_timed_thread->mutex());
snprintf(p, p_max_size, "%lu", mail->messages);
}
}
@ -1115,7 +1115,7 @@ static void pop3_thread(thread_handle &handle, struct mail_s *mail)
fail++;
break;
} else {
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
sscanf(reply, "%lu %lu", &mail->unseen, &mail->used);
}
@ -1154,10 +1154,10 @@ void print_pop3_unseen(struct text_object *obj, char *p, int p_max_size)
if (!mail)
return;
ensure_mail_thread(mail, std::bind(pop3_thread, std::placeholders::_1, std::placeholders::_2), "pop3");
ensure_mail_thread(mail, bind(pop3_thread, placeholders::_1, placeholders::_2), "pop3");
if (mail && mail->p_timed_thread) {
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
lock_guard<mutex> lock(mail->p_timed_thread->mutex());
snprintf(p, p_max_size, "%lu", mail->unseen);
}
}
@ -1169,10 +1169,10 @@ void print_pop3_used(struct text_object *obj, char *p, int p_max_size)
if (!mail)
return;
ensure_mail_thread(mail, std::bind(pop3_thread, std::placeholders::_1, std::placeholders::_2), "pop3");
ensure_mail_thread(mail, bind(pop3_thread, placeholders::_1, placeholders::_2), "pop3");
if (mail && mail->p_timed_thread) {
std::lock_guard<std::mutex> lock(mail->p_timed_thread->mutex());
lock_guard<mutex> lock(mail->p_timed_thread->mutex());
snprintf(p, p_max_size, "%.1f",
mail->used / 1024.0 / 1024.0);
}

2
src/mboxscan.cc
View File

@ -65,7 +65,7 @@ static void mbox_scan(char *args, char *output, size_t max_len)
{
int i, u, flag;
int force_rescan = 0;
std::unique_ptr<char []> buf_(new char[text_buffer_size]);
unique_ptr<char []> buf_(new char[text_buffer_size]);
char *buf = buf_.get();
struct stat statbuf;
struct ring_list *curr = 0, *prev = 0, *startlist = 0;

4
src/moc.cc
View File

@ -116,7 +116,7 @@ static void update_moc_loop(thread_handle &handle)
{
while (1) {
{
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
update_infos();
}
if (handle.test(0)) {
@ -131,7 +131,7 @@ static int run_moc_thread(double interval)
if (moc_thread)
return 0;
moc_thread = timed_thread::create(std::bind(update_moc_loop, std::placeholders::_1), interval);
moc_thread = timed_thread::create(bind(update_moc_loop, placeholders::_1), interval);
if (!moc_thread) {
NORM_ERR("Failed to create MOC timed thread");
return 1;

4
src/mpd.cc
View File

@ -136,7 +136,7 @@ void update_mpd(void)
return;
interval = info.music_player_interval * 1000000;
thread = timed_thread::create(std::bind(update_mpd_thread, std::placeholders::_1), interval);
thread = timed_thread::create(bind(update_mpd_thread, placeholders::_1), interval);
if (!thread) {
NORM_ERR("Failed to create MPD timed thread");
return;
@ -171,7 +171,7 @@ bool mpd_process(thread_handle &handle)
}
{
std::lock_guard<std::mutex> lock(handle.mutex());
lock_guard<mutex> lock(handle.mutex());
if (conn->error || conn == NULL) {
NORM_ERR("MPD error: %s\n", conn->errorStr);

70
src/proc.cc
View File

@ -60,7 +60,7 @@ char* readfile(char* filename, int* total_read, char showerror) {
void pid_readlink(char *file, char *p, int p_max_size)
{
std::unique_ptr<char []> buf(new char[p_max_size]);
unique_ptr<char []> buf(new char[p_max_size]);
memset(buf.get(), 0, p_max_size);
if(readlink(file, buf.get(), p_max_size) >= 0) {
@ -106,7 +106,7 @@ int inlist(struct ll_string* front, char* string) {
void print_pid_chroot(struct text_object *obj, char *p, int p_max_size) {
char pathbuf[64];
std::unique_ptr<char []> buf(new char[max_user_text]);
unique_ptr<char []> buf(new char[max_user_text]);
generate_text_internal(buf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/root", buf.get());
@ -118,7 +118,7 @@ void print_pid_cmdline(struct text_object *obj, char *p, int p_max_size)
char* buf;
int i, bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -141,10 +141,10 @@ void print_pid_cmdline(struct text_object *obj, char *p, int p_max_size)
void print_pid_cwd(struct text_object *obj, char *p, int p_max_size)
{
std::unique_ptr<char []> buf(new char[p_max_size]);
unique_ptr<char []> buf(new char[p_max_size]);
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/cwd", objbuf.get());
@ -162,7 +162,7 @@ void print_pid_environ(struct text_object *obj, char *p, int p_max_size)
int i, total_read;
pid_t pid;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
char *buf, *var=strdup(obj->data.s);;
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -195,7 +195,7 @@ void print_pid_environ_list(struct text_object *obj, char *p, int p_max_size)
int bytes_read, total_read;
int i = 0;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/environ", objbuf.get());
@ -217,7 +217,7 @@ void print_pid_environ_list(struct text_object *obj, char *p, int p_max_size)
void print_pid_exe(struct text_object *obj, char *p, int p_max_size) {
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/exe", objbuf.get());
@ -229,7 +229,7 @@ void print_pid_nice(struct text_object *obj, char *p, int p_max_size) {
int bytes_read;
long int nice_value;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -249,11 +249,11 @@ void print_pid_nice(struct text_object *obj, char *p, int p_max_size) {
void print_pid_openfiles(struct text_object *obj, char *p, int p_max_size) {
DIR* dir;
struct dirent *entry;
std::unique_ptr<char []> buf(new char[p_max_size]);
unique_ptr<char []> buf(new char[p_max_size]);
int length, totallength = 0;
struct ll_string* files_front = NULL;
struct ll_string* files_back = NULL;
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -288,7 +288,7 @@ void print_pid_parent(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -315,7 +315,7 @@ void print_pid_priority(struct text_object *obj, char *p, int p_max_size) {
int bytes_read;
long int priority;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -338,7 +338,7 @@ void print_pid_state(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -364,7 +364,7 @@ void print_pid_state_short(struct text_object *obj, char *p, int p_max_size) {
char *begin, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -384,7 +384,7 @@ void print_pid_state_short(struct text_object *obj, char *p, int p_max_size) {
void print_pid_stderr(struct text_object *obj, char *p, int p_max_size) {
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -393,7 +393,7 @@ void print_pid_stderr(struct text_object *obj, char *p, int p_max_size) {
}
void print_pid_stdin(struct text_object *obj, char *p, int p_max_size) {
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
char pathbuf[64];
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -404,7 +404,7 @@ void print_pid_stdin(struct text_object *obj, char *p, int p_max_size) {
void print_pid_stdout(struct text_object *obj, char *p, int p_max_size) {
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -414,7 +414,7 @@ void print_pid_stdout(struct text_object *obj, char *p, int p_max_size) {
void scan_cmdline_to_pid_arg(struct text_object *obj, const char *arg, void* free_at_crash) {
unsigned int i;
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
/* FIXME */
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -472,7 +472,7 @@ void print_pid_threads(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -499,7 +499,7 @@ void print_pid_thread_list(struct text_object *obj, char *p, int p_max_size) {
struct dirent *entry;
int totallength = 0;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/task", objbuf.get());
@ -524,7 +524,7 @@ void print_pid_time_kernelmode(struct text_object *obj, char *p, int p_max_size)
int bytes_read;
unsigned long int umtime;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -546,7 +546,7 @@ void print_pid_time_usermode(struct text_object *obj, char *p, int p_max_size) {
int bytes_read;
unsigned long int kmtime;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -568,7 +568,7 @@ void print_pid_time(struct text_object *obj, char *p, int p_max_size) {
int bytes_read;
unsigned long int umtime, kmtime;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -591,7 +591,7 @@ void print_pid_uid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -618,7 +618,7 @@ void print_pid_euid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -646,7 +646,7 @@ void print_pid_suid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -675,7 +675,7 @@ void print_pid_fsuid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -706,7 +706,7 @@ void print_pid_gid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -733,7 +733,7 @@ void print_pid_egid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -761,7 +761,7 @@ void print_pid_sgid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -790,7 +790,7 @@ void print_pid_fsgid(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -819,7 +819,7 @@ void internal_print_pid_vm(struct text_object *obj, char *p, int p_max_size, con
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/status", objbuf.get());
@ -890,7 +890,7 @@ void print_pid_read(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/io", objbuf.get());
@ -917,7 +917,7 @@ void print_pid_write(struct text_object *obj, char *p, int p_max_size) {
char *begin, *end, *buf = NULL;
int bytes_read;
char pathbuf[64];
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
snprintf(pathbuf, 64, PROCDIR "/%s/io", objbuf.get());

6
src/rss.cc
View File

@ -61,15 +61,15 @@ static void rss_process_info(char *p, int p_max_size, char *uri, char *action, i
if (!curloc->p_timed_thread) {
curloc->result = (char*)malloc(sizeof(PRSS));
memset(curloc->result, 0, sizeof(PRSS));
curloc->process_function = std::bind(prss_parse_data,
std::placeholders::_1, std::placeholders::_2);
curloc->process_function = bind(prss_parse_data,
placeholders::_1, placeholders::_2);
ccurl_init_thread(curloc, interval);
if (!curloc->p_timed_thread) {
NORM_ERR("error setting up RSS thread");
}
}
std::lock_guard<std::mutex> lock(curloc->p_timed_thread->mutex());
lock_guard<mutex> lock(curloc->p_timed_thread->mutex());
data = (PRSS*)curloc->result;
if (data == NULL || data->item_count < 1) {

2
src/scroll.cc
View File

@ -109,7 +109,7 @@ void print_scroll(struct text_object *obj, char *p, int p_max_size)
struct scroll_data *sd = (struct scroll_data *)obj->data.opaque;
unsigned int j, colorchanges = 0, frontcolorchanges = 0, visibcolorchanges = 0, strend;
char *pwithcolors;
std::vector<char> buf(max_user_text);
vector<char> buf(max_user_text);
if (!sd)
return;

2
src/specials.cc
View File

@ -358,7 +358,7 @@ static void graph_append(struct special_t *graph, double f, char showaslog)
graph->graph[0] = f; /* add new data */
if(graph->scaled) {
graph->scale = *std::max_element(graph->graph + 0, graph->graph + graph->graph_width);
graph->scale = *max_element(graph->graph + 0, graph->graph + graph->graph_width);
if(graph->scale < 1e-47) {
/* avoid NaN's when the graph is all-zero (e.g. before the first update)
* there is nothing magical about 1e-47 here */

36
src/timed-thread.cc
View File

@ -41,25 +41,25 @@
/* Abstraction layer for timed threads */
typedef struct std::chrono::system_clock clk;
typedef struct chrono::system_clock clk;
/* private */
struct _timed_thread {
std::auto_ptr<std::thread> thread; /* thread itself */
std::mutex cs_mutex; /* critical section mutex */
std::mutex runnable_mutex; /* runnable section mutex */
std::condition_variable runnable_cond; /* signalled to stop the thread */
auto_ptr<thread> the_thread; /* thread itself */
mutex cs_mutex; /* critical section mutex */
mutex runnable_mutex; /* runnable section mutex */
condition_variable runnable_cond; /* signalled to stop the thread */
clk::time_point last_time; /* last time interval */
int pipefd[2];
int die;
_timed_thread() : die(0) {}
};
typedef std::list<timed_thread_ptr> thread_list_t;
typedef list<timed_thread_ptr> thread_list_t;
thread_list_t thread_list;
/* create a timed thread (object creation only) */
timed_thread::timed_thread(const std::function<void(thread_handle &)> start_routine, unsigned
timed_thread::timed_thread(const function<void(thread_handle &)> start_routine, unsigned
int interval_usecs) :
p_timed_thread(new _timed_thread), p_thread_handle(this),
interval_usecs(interval_usecs), running(false)
@ -71,7 +71,7 @@ timed_thread::timed_thread(const std::function<void(thread_handle &)> start_rout
/* create thread pipe (used to tell threads to die) */
if (pipe(p_timed_thread->pipefd)) {
throw std::runtime_error("couldn't create pipe");
throw runtime_error("couldn't create pipe");
}
/* set initialize to current time */
@ -81,11 +81,11 @@ timed_thread::timed_thread(const std::function<void(thread_handle &)> start_rout
p_timed_thread->interval_time.tv_sec,
p_timed_thread->interval_time.tv_nsec); */
p_timed_thread->thread = std::auto_ptr<std::thread>(
new std::thread(start_routine, p_thread_handle)
p_timed_thread->the_thread = auto_ptr<thread>(
new thread(start_routine, p_thread_handle)
);
DBGP("created thread %ld", (long)p_timed_thread->thread.get());
DBGP("created thread %ld", (long)p_timed_thread->the_thread.get());
running = true;
}
@ -93,13 +93,13 @@ timed_thread::timed_thread(const std::function<void(thread_handle &)> start_rout
/* destroy a timed thread. */
void timed_thread::destroy(bool deregister_this)
{
DBGP("destroying thread %ld", (long)p_timed_thread->thread.get());
DBGP("destroying thread %ld", (long)p_timed_thread->the_thread.get());
#ifdef DEBUG
assert(running && p_timed_thread->thread->joinable());
assert(running && p_timed_thread->the_thread->joinable());
#endif /* DEBUG */
{
/* signal thread to stop */
std::lock_guard<std::mutex> l(p_timed_thread->runnable_mutex);
lock_guard<std::mutex> l(p_timed_thread->runnable_mutex);
p_timed_thread->runnable_cond.notify_one();
p_timed_thread->die = 1;
}
@ -108,7 +108,7 @@ void timed_thread::destroy(bool deregister_this)
perror("write()");
/* join the terminating thread */
p_timed_thread->thread->join();
p_timed_thread->the_thread->join();
close(p_timed_thread->pipefd[0]);
close(p_timed_thread->pipefd[1]);
@ -137,7 +137,7 @@ void timed_thread::unlock(void)
p_timed_thread->cs_mutex.unlock();
}
std::mutex &timed_thread::mutex()
mutex &timed_thread::mutex()
{
#ifdef DEBUG
assert(running);
@ -176,7 +176,7 @@ int timed_thread::test(int override_wait_time)
/* acquire runnable_cond mutex */
{
std::unique_lock<std::mutex> lock(p_timed_thread->runnable_mutex);
unique_lock<std::mutex> lock(p_timed_thread->runnable_mutex);
if (p_timed_thread->die) {
/* if we were kindly asked to die, then die */
@ -250,7 +250,7 @@ int thread_handle::test(int override_wait_time) {
return thread->test(override_wait_time);
}
std::mutex &thread_handle::mutex()
mutex &thread_handle::mutex()
{
#ifdef DEBUG
assert(thread->running);

11
src/timed-thread.h
View File

@ -25,6 +25,7 @@
#ifndef _TIMED_THREAD_H_
#define _TIMED_THREAD_H_
#include "conky.h"
#include <stdlib.h>
#include <functional>
#include <memory>
@ -36,7 +37,7 @@ const unsigned int MINIMUM_INTERVAL_USECS = 10000;
typedef struct _timed_thread _timed_thread;
class timed_thread;
typedef std::shared_ptr<timed_thread> timed_thread_ptr;
typedef shared_ptr<timed_thread> timed_thread_ptr;
namespace std { class mutex; }
@ -59,9 +60,9 @@ class thread_handle {
class timed_thread {
public:
/* create a timed thread (object creation only) */
static timed_thread_ptr create(const std::function<void(thread_handle &)> start_routine, const unsigned int
static timed_thread_ptr create(const function<void(thread_handle &)> start_routine, const unsigned int
interval_usecs, bool register_for_destruction = true) {
timed_thread_ptr ptr(new timed_thread(std::cref(start_routine), interval_usecs));
timed_thread_ptr ptr(new timed_thread(cref(start_routine), interval_usecs));
if (register_for_destruction) {
register_(ptr);
}
@ -92,7 +93,7 @@ class timed_thread {
private:
/* create a timed thread (object creation only) */
timed_thread(const std::function<void(thread_handle &)> start_routine, unsigned int
timed_thread(const function<void(thread_handle &)> start_routine, unsigned int
interval_usecs);
/* waits required interval (unless override_wait_time is non-zero) for
@ -110,7 +111,7 @@ class timed_thread {
static void deregister(const timed_thread *timed_thread);
/* private internal data */
std::auto_ptr<_timed_thread> p_timed_thread;
auto_ptr<_timed_thread> p_timed_thread;
thread_handle p_thread_handle;
unsigned int interval_usecs;
bool running;

2
src/timeinfo.cc
View File

@ -317,7 +317,7 @@ static void do_format_time(struct text_object *obj, char *p, unsigned int p_max_
void print_format_time(struct text_object *obj, char *p, int p_max_size)
{
std::unique_ptr<char []> buf(new char[max_user_text]);
unique_ptr<char []> buf(new char[max_user_text]);
generate_text_internal(buf.get(), max_user_text, *obj->sub);
obj->data.s = buf.get();

4
src/user.cc
View File

@ -39,7 +39,7 @@ void print_uid_name(struct text_object *obj, char *p, int p_max_size) {
struct passwd *pw;
uid_t uid;
char* firstinvalid;
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);
@ -61,7 +61,7 @@ void print_gid_name(struct text_object *obj, char *p, int p_max_size) {
struct group *grp;
gid_t gid;
char* firstinvalid;
std::unique_ptr<char []> objbuf(new char[max_user_text]);
unique_ptr<char []> objbuf(new char[max_user_text]);
generate_text_internal(objbuf.get(), max_user_text, *obj->sub);

20
src/weather.cc
View File

@ -717,15 +717,15 @@ static void weather_forecast_process_info(char *p, int p_max_size, char *uri, un
if (!curloc->p_timed_thread) {
curloc->result = (char*)malloc(sizeof(PWEATHER_FORECAST));
memset(curloc->result, 0, sizeof(PWEATHER_FORECAST));
curloc->process_function = std::bind(parse_weather_forecast,
std::placeholders::_1, std::placeholders::_2);
curloc->process_function = bind(parse_weather_forecast,
placeholders::_1, placeholders::_2);
ccurl_init_thread(curloc, interval);
if (!curloc->p_timed_thread) {
NORM_ERR("error setting up weather_forecast thread");
}
}
std::lock_guard<std::mutex> lock(curloc->p_timed_thread->mutex());
lock_guard<mutex> lock(curloc->p_timed_thread->mutex());
data = (PWEATHER_FORECAST*)curloc->result;
if (strcmp(data_type, "hi") == EQUAL) {
temp_print(p, p_max_size, data->hi[day], TEMP_CELSIUS);
@ -768,15 +768,15 @@ static void weather_process_info(char *p, int p_max_size, char *uri, char *data_
if (!curloc->p_timed_thread) {
curloc->result = (char*)malloc(sizeof(PWEATHER));
memset(curloc->result, 0, sizeof(PWEATHER));
curloc->process_function = std::bind(parse_weather,
std::placeholders::_1, std::placeholders::_2);
curloc->process_function = bind(parse_weather,
placeholders::_1, placeholders::_2);
ccurl_init_thread(curloc, interval);
if (!curloc->p_timed_thread) {
NORM_ERR("error setting up weather thread");
}
}
std::lock_guard<std::mutex> lock(curloc->p_timed_thread->mutex());
lock_guard<mutex> lock(curloc->p_timed_thread->mutex());
data = (PWEATHER*)curloc->result;
if (strcmp(data_type, "last_update") == EQUAL) {
strncpy(p, data->lastupd, p_max_size);
@ -832,8 +832,8 @@ static void weather_process_info(char *p, int p_max_size, char *uri, char *data_
#ifdef BUILD_WEATHER_XOAP
/* xoap suffix for weather from weather.com */
namespace {
std::string xoap_cc;
std::string xoap_df;
string xoap_cc;
string xoap_df;
}
#endif /* BUILD_WEATHER_XOAP */
@ -888,11 +888,11 @@ void load_xoap_keys(void)
fp = fopen(xoap, "r");
if (fp != NULL) {
if (fscanf(fp, "%10s %16s", par, key) == 2) {
xoap_cc = std::string("?cc=*&link=xoap&prod=xoap&par=")
xoap_cc = string("?cc=*&link=xoap&prod=xoap&par=")
+ par + "&key=" + key + "&unit=m";
/* TODO: Use FORECAST_DAYS instead of 5 */
xoap_df = std::string("?dayf=5&link=xoap&prod=xoap&par=")
xoap_df = string("?dayf=5&link=xoap&prod=xoap&par=")
+ par + "&key=" + key + "&unit=m";
}
fclose(fp);