int
zfile_output (zfile_t *self)
{
int rc;
assert (self);
// Create file path if it doesn't exist
char *file_path = strdup (self->fullname);
if (!file_path)
return -1;
char *last_slash = strrchr (file_path, '/');
if (last_slash)
*last_slash = 0;
// Wipe symbolic link if that's what the file was
if (self->link) {
freen (self->link);
self->link = NULL;
}
rc = zsys_dir_create (file_path);
freen (file_path);
if (rc != 0)
return -1;
// Create file if it doesn't exist
if (self->handle)
zfile_close (self);
self->handle = fopen (self->fullname, "r+b");
if (!self->handle)
self->handle = fopen (self->fullname, "w+b");
return self->handle? 0: -1;
}
void
zloop_destroy (zloop_t **self_p)
{
assert (self_p);
if (*self_p) {
zloop_t *self = *self_p;
// If we never started the loop, yet manipulated timers, we'll have
// a zombie list
while (zlistx_first (self->zombies)) {
// Get timer_id back from pointer
ptrdiff_t timer_id = (byte *) zlistx_detach (self->zombies, NULL) - (byte *) NULL;
s_timer_remove (self, (int) timer_id);
}
zlistx_destroy (&self->zombies);
zlistx_destroy (&self->readers);
zlistx_destroy (&self->pollers);
zlistx_destroy (&self->timers);
zlistx_destroy (&self->tickets);
freen (self->pollset);
freen (self->readact);
freen (self->pollact);
freen (self);
*self_p = NULL;
}
}
static int
s_rebuild_poll_set (zpoller_t *self)
{
freen (self->poll_set);
self->poll_set = NULL;
freen (self->poll_readers);
self->poll_readers = NULL;
self->poll_size = zlist_size (self->reader_list);
self->poll_set = (zmq_pollitem_t *)
zmalloc (self->poll_size * sizeof (zmq_pollitem_t));
self->poll_readers = (void **) zmalloc (self->poll_size * sizeof (void *));
if (!self->poll_set || !self->poll_readers)
return -1;
uint reader_nbr = 0;
void *reader = zlist_first (self->reader_list);
while (reader) {
self->poll_readers [reader_nbr] = reader;
void *socket = zsock_resolve (reader);
if (socket == NULL) {
self->poll_set [reader_nbr].socket = NULL;
self->poll_set [reader_nbr].fd = *(SOCKET *) reader;
}
else
self->poll_set [reader_nbr].socket = socket;
self->poll_set [reader_nbr].events = ZMQ_POLLIN;
reader_nbr++;
reader = zlist_next (self->reader_list);
}
self->need_rebuild = false;
return 0;
}
static void
tuple_free (void *argument)
{
tuple_t *self = (tuple_t *) argument;
freen (self->key);
freen (self->value);
freen (self);
}
static void
s_disk_loader_state_destroy (void **self_p)
{
assert (self_p);
if (*self_p) {
disk_loader_state *self = (disk_loader_state *)*self_p;
freen (self->location);
freen (self);
*self_p = NULL;
}
}
// --------------------------------------------------------------------------
// Self test of this class
void
zclock_test (bool verbose)
{
printf (" * zclock: ");
// @selftest
int64_t start = zclock_time ();
zclock_sleep (10);
assert ((zclock_time () - start) >= 10);
start = zclock_mono ();
int64_t usecs = zclock_usecs ();
zclock_sleep (10);
assert ((zclock_mono () - start) >= 10);
assert ((zclock_usecs () - usecs) >= 10000);
char *timestr = zclock_timestr ();
if (verbose)
puts (timestr);
freen (timestr);
#if defined (__WINDOWS__)
zsys_shutdown();
#endif
// @end
printf ("OK\n");
}
void
zconfig_set_name (zconfig_t *self, const char *name)
{
assert (self);
freen (self->name);
self->name = name? strdup (name): NULL;
}
void
zdir_flatten_free (zfile_t ***files_p)
{
assert (files_p);
freen (*files_p);
*files_p = NULL;
}
void
zfile_destroy (zfile_t **self_p)
{
assert (self_p);
if (*self_p) {
zfile_t *self = *self_p;
zdigest_destroy (&self->digest);
if (self->remove_on_destroy)
zfile_remove (self);
zfile_close (self);
freen (self->fullname);
freen (self->curline);
freen (self->link);
freen (self);
*self_p = NULL;
}
}
void
assert_status (zactor_t *actor, int count)
{
zstr_sendx (actor, "STATUS", NULL);
// Get STATUS reply and check it
bool ready = false;
while (!ready) {
char *command, *status;
zstr_recvx (actor, &command, &status, NULL);
if (streq (command, "STATUS")) {
assert (atoi (status) == count);
ready = true;
}
freen (command);
freen (status);
}
}
static void
s_sub_free (void *data)
{
zdir_watch_sub_t *sub = (zdir_watch_sub_t *) data;
zdir_destroy (&sub->dir);
freen (sub);
}
void
zpoller_destroy (zpoller_t **self_p)
{
assert (self_p);
if (*self_p) {
zpoller_t *self = *self_p;
#ifdef ZMQ_HAVE_POLLER
zmq_poller_destroy (&self->zmq_poller);
#else
zlist_destroy (&self->reader_list);
freen (self->poll_readers);
freen (self->poll_set);
#endif
freen (self);
*self_p = NULL;
}
}
int main(int argc, char *argv[])
/* Process command line. */
{
pushCarefulMemHandler(100000000);
if (argc != 2)
usage();
freen(argv[1]);
return 0;
}
int main(int argc, char *argv[])
/* Process command line. */
{
// optionInit(&argc, argv, options);
if (argc != 2)
usage();
freen(argv[1]);
return 0;
}
static void
s_assert_event (zactor_t *self, char *expected)
{
zmsg_t *msg = zmsg_recv (self);
assert (msg);
char *event = zmsg_popstr (msg);
assert (streq (event, expected));
freen (event);
zmsg_destroy (&msg);
}
static void
s_test_destructor (void **self_p)
{
assert (self_p);
if (*self_p) {
test_loader_state *self = (test_loader_state *)*self_p;
freen (self);
*self_p = NULL;
}
}
static void
s_timer_destroy (s_timer_t **self_p)
{
assert (self_p);
s_timer_t *self = *self_p;
if (self) {
freen (self);
*self_p = NULL;
}
}
static char *
s_collect_value (char **start, int lineno)
{
char *value = NULL;
char *readptr = *start;
int rc = 0;
while (isspace ((byte) *readptr))
readptr++;
if (*readptr == '=') {
readptr++;
while (isspace ((byte) *readptr))
readptr++;
// If value starts with quote or apost, collect it
if (*readptr == '"' || *readptr == '\'') {
char *endquote = strchr (readptr + 1, *readptr);
if (endquote) {
size_t value_length = endquote - readptr - 1;
value = (char *) zmalloc (value_length + 1);
if (!value)
return NULL;
memcpy (value, readptr + 1, value_length);
value [value_length] = 0;
rc = s_verify_eoln (endquote + 1, lineno);
}
else {
zclock_log ("E (zconfig): (%d) missing %c", lineno, *readptr);
rc = -1;
}
}
else {
// Collect unquoted value up to comment
char *comment = strchr (readptr, '#');
if (comment) {
while (isspace ((byte) comment [-1]))
comment--;
*comment = 0;
}
value = strdup (readptr);
}
}
else {
value = strdup ("");
rc = s_verify_eoln (readptr, lineno);
}
// If we had an error, drop value and return NULL
if (rc) {
freen (value);
value = NULL;
}
return value;
}
zhash_t *
zdir_cache (zdir_t *self)
{
assert (self);
// Load any previous cache from disk
zhash_t *cache = zhash_new ();
if (!cache)
return NULL;
zhash_autofree (cache);
char *cache_file = (char *) zmalloc (strlen (self->path) + strlen ("/.cache") + 1);
if (!cache_file) {
zhash_destroy (&cache);
return NULL;
}
sprintf (cache_file, "%s/.cache", self->path);
zhash_load (cache, cache_file);
// Recalculate digest for any new files
zfile_t **files = zdir_flatten (self);
uint index;
for (index = 0;; index++) {
zfile_t *file = files [index];
if (!file)
break;
const char *filename = zfile_filename (file, self->path);
if (zhash_lookup (cache, zfile_filename (file, self->path)) == NULL) {
int rc = zhash_insert (cache, filename, (void *) zfile_digest (file));
if (rc != 0) {
zhash_destroy (&cache);
break;
}
}
}
freen (files);
// Save cache to disk for future reference
if (cache)
zhash_save (cache, cache_file);
freen (cache_file);
return cache;
}
void
zrex_destroy (zrex_t **self_p)
{
assert (self_p);
if (*self_p) {
zrex_t *self = *self_p;
zstr_free (&self->hit_set);
freen (self);
*self_p = NULL;
}
}
static void
s_ticket_destroy (s_ticket_t **self_p)
{
assert (self_p);
s_ticket_t *self = *self_p;
if (self) {
self->tag = 0xDeadBeef;
freen (self);
*self_p = NULL;
}
}
void
zconfig_destroy (zconfig_t **self_p)
{
assert (self_p);
if (*self_p) {
zconfig_t *self = *self_p;
// Destroy all children and siblings recursively
zconfig_destroy (&self->child);
zconfig_destroy (&self->next);
// Destroy other properties and then self
zlist_destroy (&self->comments);
zfile_destroy (&self->file);
freen (self->name);
freen (self->value);
freen (self);
*self_p = NULL;
}
}
void
zdir_destroy (zdir_t **self_p)
{
assert (self_p);
if (*self_p) {
zdir_t *self = *self_p;
if (self->subdirs)
while (zlist_size (self->subdirs)) {
zdir_t *subdir = (zdir_t *) zlist_pop (self->subdirs);
zdir_destroy (&subdir);
}
if (self->files)
while (zlist_size (self->files)) {
zfile_t *file = (zfile_t *) zlist_pop (self->files);
zfile_destroy (&file);
}
zlist_destroy (&self->subdirs);
zlist_destroy (&self->files);
freen (self->path);
freen (self);
*self_p = NULL;
}
}
static void
s_zdir_watch_destroy (zdir_watch_t **watch_p)
{
assert (watch_p);
if (*watch_p) {
zdir_watch_t *watch = *watch_p;
zloop_destroy (&watch->loop);
zhash_destroy (&watch->subs);
freen (watch);
*watch_p = NULL;
}
}
int main(void)
{
int n;
int *number[MAXN];
init(number);
fibo(number);
while (scanf("%d", &n) == 1) {
printf("The Fibonacci number for %d is ", n);
printbig(number[n]);
}
freen(number);
return 0;
}
void
zcertstore_destroy (zcertstore_t **self_p)
{
assert (self_p);
if (*self_p) {
zcertstore_t *self = *self_p;
zhashx_destroy (&self->certs);
if (self->destructor)
self->destructor (&self->state);
freen (self);
*self_p = NULL;
}
}
zconfig_t *
zconfig_loadf (const char *format, ...)
{
va_list argptr;
va_start (argptr, format);
char *filename = zsys_vprintf (format, argptr);
va_end (argptr);
if (filename) {
zconfig_t *config = zconfig_load (filename);
freen (filename);
return config;
}
else
return NULL;
}
static int
s_rebuild_pollset (zloop_t *self)
{
self->poll_size = zlistx_size (self->readers) + zlistx_size (self->pollers);
freen (self->pollset);
self->pollset = (zmq_pollitem_t *) zmalloc (self->poll_size * sizeof (zmq_pollitem_t));
assert (self->pollset);
freen (self->readact);
self->readact = (s_reader_t *) zmalloc (self->poll_size * sizeof (s_reader_t));
assert (self->readact);
freen (self->pollact);
self->pollact = (s_poller_t *) zmalloc (self->poll_size * sizeof (s_poller_t));
assert (self->pollact);
s_reader_t *reader = (s_reader_t *) zlistx_first (self->readers);
uint item_nbr = 0;
while (reader) {
zmq_pollitem_t poll_item = { zsock_resolve (reader->sock), 0, ZMQ_POLLIN, 0 };
self->pollset [item_nbr] = poll_item;
self->readact [item_nbr] = *reader;
item_nbr++;
reader = (s_reader_t *) zlistx_next (self->readers);
}
s_poller_t *poller = (s_poller_t *) zlistx_first (self->pollers);
while (poller) {
self->pollset [item_nbr] = poller->item;
self->pollact [item_nbr] = *poller;
item_nbr++;
poller = (s_poller_t *) zlistx_next (self->pollers);
}
self->need_rebuild = false;
return 0;
}
static void
s_self_destroy (self_t **self_p)
{
assert (self_p);
if (*self_p) {
self_t *self = *self_p;
#if defined (ZMQ_EVENT_ALL)
zmq_socket_monitor (self->monitored, NULL, 0);
#endif
zpoller_destroy (&self->poller);
zsock_destroy (&self->sink);
freen (self);
*self_p = NULL;
}
}
static void
s_self_start (self_t *self)
{
assert (!self->sink);
char *endpoint = zsys_sprintf ("inproc://zmonitor-%p", self->monitored);
assert (endpoint);
int rc;
#if defined (ZMQ_EVENT_ALL)
rc = zmq_socket_monitor (self->monitored, endpoint, self->events);
assert (rc == 0);
#endif
self->sink = zsock_new (ZMQ_PAIR);
assert (self->sink);
rc = zsock_connect (self->sink, "%s", endpoint);
assert (rc == 0);
zpoller_add (self->poller, self->sink);
freen (endpoint);
}
