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); }