From: David Gibson Date: Mon, 21 Nov 2016 12:24:36 +0000 (+1100) Subject: Merge Makefile rewrite into master X-Git-Url: http://git.ozlabs.org/?p=ccan;a=commitdiff_plain;h=61f58ff94e35c9b8ac5488554e2554bc5c9888b3;hp=68c74ffd4356e26ba25b4fbbf9a8f832dcb8a0b8 Merge Makefile rewrite into master # Conflicts: # .travis.yml # Makefile # Makefile-ccan --- diff --git a/.travis.yml b/.travis.yml index 5f2097fd..d7b4318d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,11 @@ compiler: addons: apt: packages: - - libjudy-dev libvorbis-dev libportaudio-dev libtalloc-dev + - libjudy-dev + - libvorbis-dev + - libportaudio-dev + - libtalloc-dev script: - - make -j2 -k check quiet=1 + - make -j2 -k quiet=1 + - make -k check quiet=1 diff --git a/Makefile b/Makefile index ff0bad4e..6559c702 100644 --- a/Makefile +++ b/Makefile @@ -11,6 +11,7 @@ WARN_CFLAGS := -Wall -Wstrict-prototypes -Wold-style-definition -Wundef \ -Wmissing-prototypes -Wmissing-declarations -Wpointer-arith -Wwrite-strings DEP_CFLAGS = -MMD -MP -MF$(@:%=%.d) -MT$@ CCAN_CFLAGS := -g3 -ggdb $(WARN_CFLAGS) -DCCAN_STR_DEBUG=1 -I. $(CFLAGS) +CFLAGS_FORCE_C_SOURCE := -x c # Anything with an _info file is a module ... INFO_SRCS := $(wildcard ccan/*/_info ccan/*/*/_info) @@ -32,7 +33,7 @@ DEPS := $(OBJS:%=%.d) # _info files are compiled into executables and don't need dependencies %info : %_info config.h - $(PRE)$(CC) $(CCAN_CFLAGS) -I. -o $@ -x c $< + $(PRE)$(CC) $(CCAN_CFLAGS) -I. -o $@ $(CFLAGS_FORCE_C_SOURCE) $< # config.h is built by configurator which has no ccan dependencies CONFIGURATOR := tools/configurator/configurator diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 00000000..76a7e4b3 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,37 @@ +# AppVeyor CI Configuration +# +# Current build status can be viewed at +# https://ci.appveyor.com/project/dgibson/ccan +# +# To build test a fork of this repository using AppVeyor: +# 1. Visit appveyor.com and create a free account. +# 2. On the Projects tab, select "New Project" then the project hosting site. +# 3. Grant OAuth permissions to your project git host. +# 4. Select the repository for your project fork. +# 5. Review build results and push updates until the desired result is reached. + +version: 0.0.{build} + +platform: +- x86 +- amd64 + +build_script: +# Reset %PATH% to avoid msys/cygwin DLL conflicts which cause +# *** fatal error - cygheap base mismatch detected +- set PATH=C:\Windows\System32;C:\Windows;C:\Windows\System32\Wbem;C:\msys64\usr\bin +# Set environment variables for chosen compiler +- "\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\vcvarsall.bat\" %Platform%" +# Ensure config.h can be generated. +# Note: Dash options avoid POSIX path conversion by msys +- "make config.h CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash" +# FIXME: Work in progress. Disabled due to unfixed compile errors. +# FIXME: -j%NUMBER_OF_PROCESSORS% won't work without DEPGEN for config.h +# It may be possible to generate .d from cl using /showIncludes +# See https://stackoverflow.com/q/37685069 +#- "make tools CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash" +#- "make -k CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash" + +test_script: +# FIXME: Work in progress. Disabled due to unfixed compile errors. +#- "make -k check CC=cl CCAN_CFLAGS=\"-nologo -Zi -FS -W4 -wd4200 -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS\" CFLAGS_FORCE_C_SOURCE=-TC OUTPUT_OPTION=-Fo:$@ DEPGEN= LD=link SHELL=bash" diff --git a/ccan/aga/aga.h b/ccan/aga/aga.h index d09d4c72..239d36c3 100644 --- a/ccan/aga/aga.h +++ b/ccan/aga/aga.h @@ -165,6 +165,12 @@ struct aga_node { bool complete; struct lpq_link pqlink; } dijkstra; + struct { + aga_icost_t distance; + struct aga_node *prev; + const void *prevedge; + struct aga_node *list; + } bellman_ford; } u; }; @@ -177,6 +183,11 @@ struct aga_graph { aga_edge_info_fn edge_info; union { LPQ(struct aga_node, u.dijkstra.pqlink) dijkstra; + struct { + struct aga_node *nodelist; + int nnodes; + int npasses; + } bellman_ford; } state; }; @@ -347,7 +358,7 @@ struct aga_node *aga_bfs_explore(struct aga_graph *g, struct aga_node *n); * * Performs a breadth first search. The block following this macro is * executed with @_n set first to @_start, then to each node reachable - * from @_start in depth first search order. + * from @_start in breadth-first search order. * * aga_bfs_start() must be called before this macro is used. */ @@ -416,15 +427,74 @@ bool aga_dijkstra_path(struct aga_graph *g, struct aga_node *dest, struct aga_node **prev, const void **prevedge); /** - * aga_dijkstra_all_paths - Find shortest paths to all reachable nodes + * aga_dijkstra_complete - Find shortest paths to all reachable nodes * @g: graph * * Finds shortest paths from the source node (specified in * aga_dijkstra_start()) to all other reachable nodes in @g. No * results are returned directly, but between calling - * aga_dijkstra_all_paths() and aga_finish, aga_dijkstra_path() is + * aga_dijkstra_all_paths() and aga_finish(), aga_dijkstra_path() is * guaranteed to complete in O(1) time for all destinations. */ -void aga_dijkstra_all_paths(struct aga_graph *g); +void aga_dijkstra_complete(struct aga_graph *g); + +/* + * Bellman-Ford algorithm + */ + +/** + * aga_bellman_ford_start - Start Bellman-Ford algorithm + * @g: graph + * @source: source node + * + * Start's the Bellman-Ford algorithm on @g to find shortest paths + * from node @source, to other nodes in @g. + */ +int aga_bellman_ford_start(struct aga_graph *g, struct aga_node *source); + +/** + * aga_bellman_ford_path - Find the shortest path to a node + * @g: graph + * @dest: destination node + * @prev: Second last node in the path *output) + * @prevedge: Last edge in the path + * + * Finds the shortest path from the source node (specified in + * aga_bellman_ford_start() to @dest using Bellman_Ford's algorithm. + * + * If no path exists, return false. + * + * If a path does exist, returns true. Additionally if @total_cost is + * non-NULL, store the total cost of the path in *@total_cost, if + * @prev is non-NULL, store the node in the path immediately before + * @dest in *@prev and if @prevedge is non-NULL stores the edge which + * leads from *@prev to @dest in *@prevedge. + * + * If @dest is the same as source, 0 will be stored in @cost, and NULL + * will be stored in *@prev and *@prevedge. + * + * The full path from source to @dest can be determined by repeatedly + * calling aga_bellman_ford_path() on *@prev. + * + * NOTE: Bellman_Ford's algorithm will not work correctly on a graph + * which contains a cycle with (total) negative cost. If aga detects + * this case, it will set aga_error() to AGA_ERR_NEGATIVE_COST. + */ +bool aga_bellman_ford_path(struct aga_graph *g, struct aga_node *dest, + aga_icost_t *total_cost, + struct aga_node **prev, const void **prevedge); + +/** + * aga_bellman_ford_complete - Run Bellman-Ford algorithm to completion + * @g: graph + * + * Finds shortest paths from the source node (specified in + * aga_bellman_ford_start()) to all other reachable nodes in @g. No + * results are returned directly, but between calling + * aga_bellman_ford_complete() and aga_finish(), + * aga_bellman_ford_path() is guaranteed to complete in O(1) time for + * all destinations. + */ +void aga_bellman_ford_complete(struct aga_graph *g); #endif /* CCAN_AGA_H */ diff --git a/ccan/aga/bellman_ford.c b/ccan/aga/bellman_ford.c new file mode 100644 index 00000000..18204831 --- /dev/null +++ b/ccan/aga/bellman_ford.c @@ -0,0 +1,141 @@ +/* Licensed under LGPLv2+ - see LICENSE file for details */ +#include "config.h" + +#include +#include +#include + +#include +#include +#include + +#include +#include "private.h" + +/* + * The Bellman-Ford algorithm + */ + +static bool candidate_path(struct aga_graph *g, struct aga_node *node, + aga_icost_t distance, + struct aga_node *prev, const void *prevedge) +{ + if (aga_update_node(g, node)) { + /* New node, treat as having infinite distance */ + node->u.bellman_ford.distance = distance; + node->u.bellman_ford.prev = prev; + node->u.bellman_ford.prevedge = prevedge; + + node->u.bellman_ford.list = g->state.bellman_ford.nodelist; + g->state.bellman_ford.nodelist = node; + g->state.bellman_ford.nnodes++; + + return true; + } else if (distance < node->u.bellman_ford.distance) { + node->u.bellman_ford.distance = distance; + node->u.bellman_ford.prev = prev; + node->u.bellman_ford.prevedge = prevedge; + } + return false; +} + +int aga_bellman_ford_start(struct aga_graph *g, struct aga_node *source) +{ + int rc; + + /* Make sure we're actually using the right ordering for + * aga_icost_t */ + BUILD_ASSERT(check_types_match(long, aga_icost_t) == 0); + + rc = aga_start(g); + if (rc < 0) + return rc; + + g->state.bellman_ford.nodelist = NULL; + g->state.bellman_ford.nnodes = 0; + g->state.bellman_ford.npasses = 0; + + candidate_path(g, source, 0, NULL, NULL); + + return 0; +} + +static bool aga_bellman_ford_step(struct aga_graph *g) +{ + struct aga_node *n; + const void *e; + struct aga_edge_info ei; + int err; + bool newnode = false; + + if (!aga_check_state(g)) + return false; + + for (n = g->state.bellman_ford.nodelist; + n; n = n->u.bellman_ford.list) { + aga_for_each_edge_info(e, ei, err, g, n) { + aga_icost_t dist = n->u.bellman_ford.distance + + ei.icost; + newnode = newnode || candidate_path(g, ei.to, dist, n, e); + } + if (err) { + aga_fail(g, err); + return false; + } + } + g->state.bellman_ford.npasses++; + return newnode || (g->state.bellman_ford.npasses + < g->state.bellman_ford.nnodes); +} + +void aga_bellman_ford_complete(struct aga_graph *g) +{ + struct aga_node *n; + const void *e; + struct aga_edge_info ei; + int err; + + if (!aga_check_state(g)) + return; + + while (aga_bellman_ford_step(g)) + ; + + /* Check for negative cycles */ + for (n = g->state.bellman_ford.nodelist; + n; n = n->u.bellman_ford.list) { + aga_for_each_edge_info(e, ei, err, g, n) { + if ((n->u.bellman_ford.distance + ei.icost) + < ei.to->u.bellman_ford.distance) { + aga_fail(g, AGA_ERR_NEGATIVE_COST); + return; + } + } + if (err) { + aga_fail(g, err); + return; + } + } +} + +bool aga_bellman_ford_path(struct aga_graph *g, struct aga_node *node, + aga_icost_t *total_cost, + struct aga_node **prev, const void **prevedge) +{ + aga_bellman_ford_complete(g); + + if (!aga_check_state(g)) + return false; + + if (aga_node_needs_update(g, node)) + return false; + + if (total_cost) + *total_cost = node->u.bellman_ford.distance; + if (prev) + *prev = node->u.bellman_ford.prev; + if (prevedge) + *prevedge = node->u.bellman_ford.prevedge; + + return true; +} diff --git a/ccan/aga/dijkstra.c b/ccan/aga/dijkstra.c index 02177fb8..cbb79b90 100644 --- a/ccan/aga/dijkstra.c +++ b/ccan/aga/dijkstra.c @@ -114,7 +114,7 @@ bool aga_dijkstra_path(struct aga_graph *g, struct aga_node *node, return true; } -void aga_dijkstra_all_paths(struct aga_graph *g) +void aga_dijkstra_complete(struct aga_graph *g) { if (!aga_check_state(g)) return; diff --git a/ccan/aga/test/api-adjacency.c b/ccan/aga/test/api-adjacency.c index 6e504301..31685224 100644 --- a/ccan/aga/test/api-adjacency.c +++ b/ccan/aga/test/api-adjacency.c @@ -63,8 +63,9 @@ int main(void) struct traversal1_graph t1g; struct shortcut1_graph s1g; struct shortcut2_graph s2g; + struct negacycle_graph ng; - plan_tests(2 + 7 + 35 + 30 + 30 + 42 + 9 + 30 + 9 + 9); + plan_tests(2 + 7 + 35 + 30 + 30 + 42 + 9 + 30 + 9 + 9 + 9); trivial_graph_init(&tg); test_adjacency("trivial", &tg.sg, trivial_adjacency); @@ -99,5 +100,8 @@ int main(void) shortcut2_graph_init(&s2g); test_adjacency("shortcut2 graph", &s2g.sg, shortcut2_adjacency); + negacycle_graph_init(&ng); + test_adjacency("negacycle graph", &ng.sg, negacycle_adjacency); + return exit_status(); } diff --git a/ccan/aga/test/api-bellman_ford.c b/ccan/aga/test/api-bellman_ford.c new file mode 100644 index 00000000..5dc032a7 --- /dev/null +++ b/ccan/aga/test/api-bellman_ford.c @@ -0,0 +1,279 @@ +#include "config.h" + +#include +#include +#include + +#include +#include + +#include + +#include "simple-graph.h" + +static void test_trivial(void) +{ + struct trivial_graph tg; + aga_icost_t cost; + struct aga_node *node; + const void *edge; + + trivial_graph_init(&tg); + + ok1(aga_bellman_ford_start(&tg.sg.g, &tg.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&tg.sg.g, &tg.sg.nodes[1], &cost, &node, &edge)); + ok1(cost == 0); + ok1(node == NULL); + ok1(edge == NULL); + aga_finish(&tg.sg.g); +} + +static void test_parallel(void) +{ + struct parallel_graph pg; + aga_icost_t cost; + struct aga_node *node; + const void *edge; + + parallel_graph_init(&pg, 3, 0); + + ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[1], &cost, NULL, NULL)); + ok1(cost == 0); + ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == &pg.sg.nodes[1]); + aga_finish(&pg.sg.g); + + ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[2]) == 0); + ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, NULL, NULL)); + ok1(cost == 0); + ok1(!aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[1], NULL, NULL, NULL)); + aga_finish(&pg.sg.g); + + + parallel_graph_init(&pg, 3, 2); + ok1(aga_bellman_ford_start(&pg.sg.g, &pg.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&pg.sg.g, &pg.sg.nodes[2], &cost, &node, &edge)); + ok1(cost == 1); + ok1(node == &pg.sg.nodes[1]); + ok1(ptr2int(edge) == 2); + aga_finish(&pg.sg.g); +} + +#define FULL_LEN 4 + +static void test_full(void) +{ + struct full_graph fg; + int i, j; + + full_graph_init(&fg, FULL_LEN); + + for (i = 1; i <= FULL_LEN; i++) { + ok1(aga_bellman_ford_start(&fg.sg.g, &fg.sg.nodes[i]) == 0); + + for (j = 1; j <= FULL_LEN; j++) { + aga_icost_t cost; + struct aga_node *node; + const void *edge; + + ok1(aga_bellman_ford_path(&fg.sg.g, &fg.sg.nodes[j], + &cost, &node, &edge)); + if (i == j) { + ok1(cost == 0); + ok1(node == NULL); + ok1(edge == NULL); + } else { + ok1(cost == 1); + ok1(node == &fg.sg.nodes[i]); + ok1(edge == &fg.sg.nodes[j]); + } + } + + aga_finish(&fg.sg.g); + } +} + +#define CHAIN_LEN 8 + +static void test_chain(void) +{ + struct chain_graph cg; + int i, j; + + chain_graph_init(&cg, CHAIN_LEN); + + for (i = 1; i <= CHAIN_LEN; i++) { + ok1(aga_bellman_ford_start(&cg.fg.sg.g, &cg.fg.sg.nodes[i]) == 0); + + for (j = 1; j <= CHAIN_LEN; j++) { + aga_icost_t cost; + + ok1(aga_bellman_ford_path(&cg.fg.sg.g, &cg.fg.sg.nodes[j], + &cost, NULL, NULL)); + ok1(cost == labs(i - j)); + } + + aga_finish(&cg.fg.sg.g); + } +} + +static void test_error(void) +{ + struct error_graph eg; + aga_icost_t cost; + + error_graph_init(&eg); + + ok1(aga_bellman_ford_start(&eg.sg.g, &eg.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[1], &cost, NULL, NULL)); + ok1(cost == 0); + ok1(aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[2], &cost, NULL, NULL)); + ok1(cost == 1); + ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[3], &cost, NULL, NULL)); + ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[4], &cost, NULL, NULL)); + aga_finish(&eg.sg.g); + + ok1(aga_bellman_ford_start(&eg.sg.g, &eg.sg.nodes[3]) == 0); + aga_bellman_ford_complete(&eg.sg.g); + ok1(!aga_bellman_ford_path(&eg.sg.g, &eg.sg.nodes[4], &cost, NULL, NULL)); + ok1(aga_error(&eg.sg.g) == -1); + aga_finish(&eg.sg.g); +} + +static void test_traversal1(void) +{ + struct traversal1_graph t1g; + aga_icost_t cost; + + /* This is mostly about testing we correctly handle + * non-reachable nodes */ + traversal1_graph_init(&t1g); + + ok1(aga_bellman_ford_start(&t1g.sg.g, &t1g.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[1], + &cost, NULL, NULL)); + ok1(cost == 0); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[2], + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[3], + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[4], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[5], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[6], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[7], + NULL, NULL, NULL)); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[8], + NULL, NULL, NULL)); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[9], + NULL, NULL, NULL)); + aga_finish(&t1g.sg.g); + + ok1(aga_bellman_ford_start(&t1g.sg.g, &t1g.sg.nodes[9]) == 0); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[9], + &cost, NULL, NULL)); + ok1(cost == 0); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[8], + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[7], + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[6], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[5], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[4], + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[3], + NULL, NULL, NULL)); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[2], + NULL, NULL, NULL)); + ok1(!aga_bellman_ford_path(&t1g.sg.g, &t1g.sg.nodes[1], + NULL, NULL, NULL)); + aga_finish(&t1g.sg.g); +} + +static void test_shortcut1(void) +{ + struct shortcut1_graph s1g; + aga_icost_t cost; + struct aga_node *node; + + shortcut1_graph_init(&s1g); + + ok1(aga_bellman_ford_start(&s1g.sg.g, &s1g.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&s1g.sg.g, &s1g.sg.nodes[3], + &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == &s1g.sg.nodes[2]); + ok1(aga_bellman_ford_path(&s1g.sg.g, &s1g.sg.nodes[2], + &cost, &node, NULL)); + ok1(cost == 1); + ok1(node == &s1g.sg.nodes[1]); + aga_finish(&s1g.sg.g); +} + +static void test_shortcut2(void) +{ + struct shortcut2_graph s2g; + aga_icost_t cost; + struct aga_node *node; + + shortcut2_graph_init(&s2g); + + ok1(aga_bellman_ford_start(&s2g.sg.g, &s2g.sg.nodes[1]) == 0); + ok1(aga_bellman_ford_path(&s2g.sg.g, &s2g.sg.nodes[3], + &cost, &node, NULL)); + ok1(cost == 1); + ok1(node == &s2g.sg.nodes[2]); + ok1(aga_bellman_ford_path(&s2g.sg.g, &s2g.sg.nodes[2], + &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == &s2g.sg.nodes[1]); + aga_finish(&s2g.sg.g); +} + +static void test_negacycle(void) +{ + struct negacycle_graph ng; + + negacycle_graph_init(&ng); + + ok1(aga_bellman_ford_start(&ng.sg.g, &ng.sg.nodes[1]) == 0); + aga_bellman_ford_complete(&ng.sg.g); + ok1(aga_error(&ng.sg.g) == AGA_ERR_NEGATIVE_COST); + aga_finish(&ng.sg.g); +} + +int main(void) +{ + plan_tests(5 + 15 + + FULL_LEN * (1 + FULL_LEN * 4) + + CHAIN_LEN * (1 + CHAIN_LEN * 2) + + 10 + 32 + 7 + 7 + 2); + + test_trivial(); + test_parallel(); + test_full(); + test_chain(); + test_error(); + test_traversal1(); + test_shortcut1(); + test_shortcut2(); + test_negacycle(); + + return exit_status(); +} diff --git a/ccan/aga/test/api-bfs.c b/ccan/aga/test/api-bfs.c index 90fcc628..1a3e1411 100644 --- a/ccan/aga/test/api-bfs.c +++ b/ccan/aga/test/api-bfs.c @@ -42,9 +42,10 @@ int main(void) struct grid_graph gg1, gg2; struct error_graph eg; struct traversal1_graph t1g; + struct negacycle_graph ng; struct aga_node *node; - plan_tests(2 * 13 + 10 + 10); + plan_tests(2 * 13 + 10 + 10 + 6); trivial_graph_init(&tg); test_bfs(&tg.sg, 1, 1); @@ -100,5 +101,10 @@ int main(void) test_bfs_partial(&t1g.sg, 1, 1, 2, 3); aga_finish(&t1g.sg.g); + negacycle_graph_init(&ng); + test_bfs(&ng.sg, 1, 1, 2, 3); + test_bfs(&ng.sg, 2, 2, 3, 1); + test_bfs(&ng.sg, 3, 3, 1, 2); + return exit_status(); } diff --git a/ccan/aga/test/api-dfs.c b/ccan/aga/test/api-dfs.c index 24d1a4f9..c28097a6 100644 --- a/ccan/aga/test/api-dfs.c +++ b/ccan/aga/test/api-dfs.c @@ -42,9 +42,10 @@ int main(void) struct grid_graph gg1, gg2; struct error_graph eg; struct traversal1_graph t1g; + struct negacycle_graph ng; struct aga_node *node; - plan_tests(2 * 13 + 10 + 10); + plan_tests(2 * 13 + 10 + 10 + 6); trivial_graph_init(&tg); test_dfs(&tg.sg, 1, 1); @@ -100,5 +101,10 @@ int main(void) test_dfs_partial(&t1g.sg, 1, 1, 2, 3); aga_finish(&t1g.sg.g); + negacycle_graph_init(&ng); + test_dfs(&ng.sg, 1, 1, 2, 3); + test_dfs(&ng.sg, 2, 2, 3, 1); + test_dfs(&ng.sg, 3, 3, 1, 2); + return exit_status(); } diff --git a/ccan/aga/test/api-dijkstra.c b/ccan/aga/test/api-dijkstra.c index f9b8d764..01bb5aa4 100644 --- a/ccan/aga/test/api-dijkstra.c +++ b/ccan/aga/test/api-dijkstra.c @@ -241,17 +241,29 @@ static void test_shortcut2(void) shortcut2_graph_init(&s2g); ok1(aga_dijkstra_start(&s2g.sg.g, &s2g.sg.nodes[1]) == 0); - aga_dijkstra_all_paths(&s2g.sg.g); + aga_dijkstra_complete(&s2g.sg.g); ok1(aga_error(&s2g.sg.g) == AGA_ERR_NEGATIVE_COST); aga_finish(&s2g.sg.g); } +static void test_negacycle(void) +{ + struct negacycle_graph ng; + + negacycle_graph_init(&ng); + + ok1(aga_dijkstra_start(&ng.sg.g, &ng.sg.nodes[1]) == 0); + aga_dijkstra_complete(&ng.sg.g); + ok1(aga_error(&ng.sg.g) == AGA_ERR_NEGATIVE_COST); + aga_finish(&ng.sg.g); +} + int main(void) { plan_tests(7 + 20 + FULL_LEN * (1 + FULL_LEN*4) + CHAIN_LEN * (1 + CHAIN_LEN*2) - + 12 + 32 + 7 + 2); + + 12 + 32 + 7 + 2 + 2); test_trivial(); test_parallel(); @@ -261,6 +273,7 @@ int main(void) test_traversal1(); test_shortcut1(); test_shortcut2(); + test_negacycle(); return exit_status(); } diff --git a/ccan/aga/test/negacycle.c b/ccan/aga/test/negacycle.c new file mode 100644 index 00000000..8eae4bf0 --- /dev/null +++ b/ccan/aga/test/negacycle.c @@ -0,0 +1,46 @@ +#include "config.h" + +#include + +#include +#include + +#include + +#include "simple-graph.h" + +static ptrint_t *negacycle_first_edge(const struct aga_graph *g, + const struct aga_node *n) +{ + return int2ptr(1); +} + +static ptrint_t *negacycle_next_edge(const struct aga_graph *g, + const struct aga_node *n, + ptrint_t *e) +{ + assert(ptr2int(e) == 1); + return NULL; +} + +static int negacycle_edge_info(const struct aga_graph *g, + const struct aga_node *n, + ptrint_t *e, struct aga_edge_info *ei) +{ + struct negacycle_graph *ng = container_of(g, struct negacycle_graph, + sg.g); + int ni = n - ng->sg.nodes; + + assert(ptr2int(e) == 1); + ei->to = &ng->sg.nodes[(ni % 3) + 1]; + if (ni == 3) + ei->icost = -3; + return 0; +} + +void negacycle_graph_init(struct negacycle_graph *ng) +{ + simple_graph_init(&ng->sg, negacycle_first_edge, + negacycle_next_edge, + negacycle_edge_info); +} diff --git a/ccan/aga/test/simple-graph.h b/ccan/aga/test/simple-graph.h index b8da3ad9..5808993a 100644 --- a/ccan/aga/test/simple-graph.h +++ b/ccan/aga/test/simple-graph.h @@ -256,4 +256,23 @@ static const struct adjacency_list shortcut2_adjacency[] = { {}, }; +/* Negacycle graph + * + * A <---- (-3) ----- C + * \ ^ + * (1)-> B -- (1)-/ + * + * Graph with a negative length cycle, and so lacking well-defined shortest paths. + */ +struct negacycle_graph { + struct simple_graph sg; +}; +void negacycle_graph_init(struct negacycle_graph *ng); +static const struct adjacency_list negacycle_adjacency[] = { + {1, {2}}, + {2, {3}}, + {3, {1}}, + {}, +}; + #endif /* _TEST_GRAPHS_H */ diff --git a/ccan/agar/agar.c b/ccan/agar/agar.c index e930d7aa..aa462840 100644 --- a/ccan/agar/agar.c +++ b/ccan/agar/agar.c @@ -286,8 +286,53 @@ bool agar_dijkstra_path(struct agar_state *sr, const void *destr, return true; } -void agar_dijkstra_all_paths(struct agar_state *sr) +void agar_dijkstra_complete(struct agar_state *sr) { - aga_dijkstra_all_paths(&sr->g); + aga_dijkstra_complete(&sr->g); } + +/* + * Bellman-Ford algorithm + */ + +struct agar_state *agar_bellman_ford_new(void *ctx, struct agar_graph *gr, + const void *nr) +{ + struct agar_state *sr = agar_new(ctx, gr); + + if (aga_bellman_ford_start(&sr->g, nr_to_n(sr, nr)) < 0) { + tal_free(sr); + return NULL; + } + + return sr; +} + +bool agar_bellman_ford_path(struct agar_state *sr, const void *destr, + aga_icost_t *total_cost, + const void **prevr, const void **prevedge) +{ + struct aga_node *dest = nr_to_n(sr, destr); + struct aga_node *prev; + + if (!aga_bellman_ford_path(&sr->g, dest, total_cost, &prev, prevedge)) + return false; + + /* + * When destr is the same as the source node, there obviously + * isn't a previous node or edge. In that case aga sets them + * to NULL. But for agar, NULL could be a valid node + * references (particularly if using ptrint). So we don't + * have much choice here but to leave *prevr as undefined when + * destr is the source node. */ + if (prevr && prev) + *prevr = n_to_nr(sr, prev); + + return true; +} + +void agar_bellman_ford_complete(struct agar_state *sr) +{ + aga_bellman_ford_complete(&sr->g); +} diff --git a/ccan/agar/agar.h b/ccan/agar/agar.h index abd11301..f65b4e37 100644 --- a/ccan/agar/agar.h +++ b/ccan/agar/agar.h @@ -84,6 +84,18 @@ bool agar_dijkstra_step(struct agar_state *sr, const void **nextr); bool agar_dijkstra_path(struct agar_state *sr, const void *destr, aga_icost_t *total_cost, const void **prevr, const void **prevedge); -void agar_dijkstra_all_paths(struct agar_state *sr); +void agar_dijkstra_complete(struct agar_state *sr); + +/* + * Bellman-Ford algorithm + */ + +struct agar_state *agar_bellman_ford_new(void *ctx, struct agar_graph *gr, + const void *nr); + +bool agar_bellman_ford_path(struct agar_state *sr, const void *destr, + aga_icost_t *total_cost, + const void **prevr, const void **prevedge); +void agar_bellman_ford_complete(struct agar_state *sr); #endif /* CCAN_AGAR_H */ diff --git a/ccan/agar/test/api-bellman_ford.c b/ccan/agar/test/api-bellman_ford.c new file mode 100644 index 00000000..a161b0ca --- /dev/null +++ b/ccan/agar/test/api-bellman_ford.c @@ -0,0 +1,260 @@ +#include "config.h" + +#include +#include +#include + +#include +#include +#include + +#include + +#include "simple-graphr.h" + +static void test_trivial(void) +{ + struct agar_state *sr; + aga_icost_t cost; + + ok1(sr = agar_bellman_ford_new(NULL, &trivial_graphr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL)); + ok1(cost == 0); + tal_free(sr); +} + +static void test_parallel(void) +{ + struct parallel_graphr pgr; + struct agar_state *sr; + aga_icost_t cost; + const void *node, *edge; + + parallel_graphr_init(&pgr, 3, 0); + + ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL)); + ok1(cost == 0); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == int2ptr(1)); + tal_free(sr); + + ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(2))); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, NULL, NULL)); + ok1(cost == 0); + ok1(!agar_bellman_ford_path(sr, int2ptr(1), NULL, NULL, NULL)); + tal_free(sr); + + parallel_graphr_init(&pgr, 3, 2); + ok1(sr = agar_bellman_ford_new(NULL, &pgr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, &edge)); + ok1(cost == 1); + ok1(ptr2int(node) == 1); + ok1(ptr2int(edge) == 2); + tal_free(sr); +} + +#define FULL_LEN 4 + +static void test_full(void) +{ + struct full_graphr fgr; + int i, j; + + full_graphr_init(&fgr, FULL_LEN); + + for (i = 1; i <= FULL_LEN; i++) { + struct agar_state *sr; + + ok1(sr = agar_bellman_ford_new(NULL, &fgr.gr, int2ptr(i))); + + for (j = 1; j <= FULL_LEN; j++) { + aga_icost_t cost; + const void *node, *edge; + + ok1(agar_bellman_ford_path(sr, int2ptr(j), + &cost, &node, &edge)); + if (i == j) { + ok1(cost == 0); + } else { + ok1(cost == 1); + ok1(node == int2ptr(i)); + ok1(edge == int2ptr(j)); + } + } + + tal_free(sr); + } +} + +#define CHAIN_LEN 8 + +static void test_chain(void) +{ + struct chain_graphr cgr; + int i, j; + + chain_graphr_init(&cgr, CHAIN_LEN); + + for (i = 1; i <= CHAIN_LEN; i++) { + struct agar_state *sr; + + ok1(sr = agar_bellman_ford_new(NULL, &cgr.fgr.gr, int2ptr(i))); + + for (j = 1; j <= CHAIN_LEN; j++) { + aga_icost_t cost; + + ok1(agar_bellman_ford_path(sr, int2ptr(j), + &cost, NULL, NULL)); + ok1(cost == labs(i - j)); + } + + tal_free(sr); + } +} + +static void test_error(void) +{ + struct agar_state *sr; + aga_icost_t cost; + + ok1(sr = agar_bellman_ford_new(NULL, &error_graphr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(1), &cost, NULL, NULL)); + ok1(cost == 0); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, NULL, NULL)); + ok1(cost == 1); + ok1(!agar_bellman_ford_path(sr, int2ptr(3), &cost, NULL, NULL)); + ok1(!agar_bellman_ford_path(sr, int2ptr(4), &cost, NULL, NULL)); + tal_free(sr); + + ok1(sr = agar_bellman_ford_new(NULL, &error_graphr.gr, int2ptr(3))); + agar_bellman_ford_complete(sr); + ok1(!agar_bellman_ford_path(sr, int2ptr(4), &cost, NULL, NULL)); + ok1(agar_error(sr) == -1); + tal_free(sr); +} + +static void test_traversal1(void) +{ + struct agar_state *sr; + aga_icost_t cost; + + /* This is mostly about testing we correctly handle + * non-reachable nodes */ + ok1(sr = agar_bellman_ford_new(NULL, &traversal1_graphr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(1), + &cost, NULL, NULL)); + ok1(cost == 0); + ok1(agar_bellman_ford_path(sr, int2ptr(2), + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(agar_bellman_ford_path(sr, int2ptr(3), + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(agar_bellman_ford_path(sr, int2ptr(4), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(agar_bellman_ford_path(sr, int2ptr(5), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(agar_bellman_ford_path(sr, int2ptr(6), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(!agar_bellman_ford_path(sr, int2ptr(7), + NULL, NULL, NULL)); + ok1(!agar_bellman_ford_path(sr, int2ptr(8), + NULL, NULL, NULL)); + ok1(!agar_bellman_ford_path(sr, int2ptr(9), + NULL, NULL, NULL)); + tal_free(sr); + + ok1(sr = agar_bellman_ford_new(NULL, &traversal1_graphr.gr, int2ptr(9))); + ok1(agar_bellman_ford_path(sr, int2ptr(9), + &cost, NULL, NULL)); + ok1(cost == 0); + ok1(agar_bellman_ford_path(sr, int2ptr(8), + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(agar_bellman_ford_path(sr, int2ptr(7), + &cost, NULL, NULL)); + ok1(cost == 1); + ok1(agar_bellman_ford_path(sr, int2ptr(6), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(agar_bellman_ford_path(sr, int2ptr(5), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(agar_bellman_ford_path(sr, int2ptr(4), + &cost, NULL, NULL)); + ok1(cost == 2); + ok1(!agar_bellman_ford_path(sr, int2ptr(3), + NULL, NULL, NULL)); + ok1(!agar_bellman_ford_path(sr, int2ptr(2), + NULL, NULL, NULL)); + ok1(!agar_bellman_ford_path(sr, int2ptr(1), + NULL, NULL, NULL)); + tal_free(sr); +} + +static void test_shortcut1(void) +{ + struct agar_state *sr; + aga_icost_t cost; + const void *node; + + ok1(sr = agar_bellman_ford_new(NULL, &shortcut1_graphr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(3), &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == int2ptr(2)); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL)); + ok1(cost == 1); + ok1(node == int2ptr(1)); + tal_free(sr); +} + +static void test_shortcut2(void) +{ + struct agar_state *sr; + aga_icost_t cost; + const void *node; + + ok1(sr = agar_bellman_ford_new(NULL, &shortcut2_graphr.gr, int2ptr(1))); + ok1(agar_bellman_ford_path(sr, int2ptr(3), &cost, &node, NULL)); + ok1(cost == 1); + ok1(node == int2ptr(2)); + ok1(agar_bellman_ford_path(sr, int2ptr(2), &cost, &node, NULL)); + ok1(cost == 2); + ok1(node == int2ptr(1)); + tal_free(sr); +} + +static void test_negacycle(void) +{ + struct agar_state *sr; + + ok1(sr = agar_bellman_ford_new(NULL, &negacycle_graphr.gr, int2ptr(1))); + agar_bellman_ford_complete(sr); + ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST); + tal_free(sr); +} + +int main(void) +{ + plan_tests(3 + 15 + + FULL_LEN * (FULL_LEN*4 - 1) + + CHAIN_LEN * (1 + CHAIN_LEN*2) + + 10 + 32 + 7 + 7 + 2); + + test_trivial(); + test_parallel(); + test_full(); + test_chain(); + test_error(); + test_traversal1(); + test_shortcut1(); + test_shortcut2(); + test_negacycle(); + + return exit_status(); +} diff --git a/ccan/agar/test/api-bfs.c b/ccan/agar/test/api-bfs.c index 27369b6e..79ea21ad 100644 --- a/ccan/agar/test/api-bfs.c +++ b/ccan/agar/test/api-bfs.c @@ -45,7 +45,7 @@ int main(void) struct agar_state *sr; const void *nr; - plan_tests(2 * 13 + 12 + 10); + plan_tests(2 * 13 + 12 + 10 + 6); test_bfs(&trivial_graphr.gr, 1, 1); @@ -97,5 +97,9 @@ int main(void) test_bfs_partial(sr, 1, 1, 2, 3); tal_free(sr); + test_bfs(&negacycle_graphr.gr, 1, 1, 2, 3); + test_bfs(&negacycle_graphr.gr, 2, 2, 3, 1); + test_bfs(&negacycle_graphr.gr, 3, 3, 1, 2); + return exit_status(); } diff --git a/ccan/agar/test/api-dfs.c b/ccan/agar/test/api-dfs.c index 625e825c..65be2e18 100644 --- a/ccan/agar/test/api-dfs.c +++ b/ccan/agar/test/api-dfs.c @@ -45,7 +45,7 @@ int main(void) struct agar_state *sr; const void *nr; - plan_tests(2 * 13 + 12 + 10); + plan_tests(2 * 13 + 12 + 10 + 6); test_dfs(&trivial_graphr.gr, 1, 1); @@ -97,5 +97,9 @@ int main(void) test_dfs_partial(sr, 1, 1, 2, 3); tal_free(sr); + test_dfs(&negacycle_graphr.gr, 1, 1, 2, 3); + test_dfs(&negacycle_graphr.gr, 2, 2, 3, 1); + test_dfs(&negacycle_graphr.gr, 3, 3, 1, 2); + return exit_status(); } diff --git a/ccan/agar/test/api-dijkstra.c b/ccan/agar/test/api-dijkstra.c index ebdbf42d..19980919 100644 --- a/ccan/agar/test/api-dijkstra.c +++ b/ccan/agar/test/api-dijkstra.c @@ -231,7 +231,17 @@ static void test_shortcut2(void) struct agar_state *sr; ok1(sr = agar_dijkstra_new(NULL, &shortcut2_graphr.gr, int2ptr(1))); - agar_dijkstra_all_paths(sr); + agar_dijkstra_complete(sr); + ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST); + tal_free(sr); +} + +static void test_negacycle(void) +{ + struct agar_state *sr; + + ok1(sr = agar_dijkstra_new(NULL, &negacycle_graphr.gr, int2ptr(1))); + agar_dijkstra_complete(sr); ok1(agar_error(sr) == AGA_ERR_NEGATIVE_COST); tal_free(sr); } @@ -241,7 +251,7 @@ int main(void) plan_tests(6 + 23 + FULL_LEN * (FULL_LEN*4 - 1) + CHAIN_LEN * (1 + CHAIN_LEN*2) - + 12 + 32 + 7 + 2); + + 12 + 32 + 7 + 2 + 2); test_trivial(); test_parallel(); @@ -251,6 +261,7 @@ int main(void) test_traversal1(); test_shortcut1(); test_shortcut2(); + test_negacycle(); return exit_status(); } diff --git a/ccan/agar/test/negacycle.c b/ccan/agar/test/negacycle.c new file mode 100644 index 00000000..7d3daa96 --- /dev/null +++ b/ccan/agar/test/negacycle.c @@ -0,0 +1,42 @@ +#include "config.h" + +#include + +#include +#include + +#include + +#include "simple-graphr.h" + +static const void *negacycle_first_edge_r(const struct agar_graph *gr, + const void *nr) +{ + return int2ptr(1); +} + +static const void *negacycle_next_edge_r(const struct agar_graph *gr, + const void *nr, const void *e) +{ + assert(ptr2int(e) == 1); + return NULL; +} + +static int negacycle_edge_info_r(const struct agar_graph *gr, + const void *nr, const void *e, + struct agar_edge_info *eir) +{ + int ni = ptr2int(nr); + + assert(ptr2int(e) == 1); + eir->to = int2ptr((ni % 3) + 1); + if (ni == 3) + eir->icost = -3; + return 0; +} + +struct negacycle_graphr negacycle_graphr = { + AGAR_INIT_GRAPH(negacycle_first_edge_r, + negacycle_next_edge_r, + negacycle_edge_info_r), +}; diff --git a/ccan/agar/test/simple-graphr.h b/ccan/agar/test/simple-graphr.h index ddb1edbc..21cae6a3 100644 --- a/ccan/agar/test/simple-graphr.h +++ b/ccan/agar/test/simple-graphr.h @@ -240,4 +240,23 @@ static const struct adjacency_listr shortcut2_adjacencyr[] = { {}, }; +/* Negacycle graph + * + * A <---- (-3) ----- C + * \ ^ + * (1)-> B -- (1)-/ + * + * Graph with a negative length cycle, and so lacking well-defined shortest paths. + */ +struct negacycle_graphr { + struct agar_graph gr; +}; +extern struct negacycle_graphr negacycle_graphr; +static const struct adjacency_listr negacycle_adjacencyr[] = { + {1, {2}}, + {2, {3}}, + {3, {1}}, + {}, +}; + #endif /* _SIMPLE_GRAPHR_H */ diff --git a/ccan/alignof/_info b/ccan/alignof/_info index e0952c65..ee2b7ad0 100644 --- a/ccan/alignof/_info +++ b/ccan/alignof/_info @@ -21,7 +21,7 @@ * * // Output contains "ALIGNOF(char) == 1" * // Will also print out whether an onstack char array can hold a long. - * int main(int argc, char *argv[]) + * int main(void) * { * char arr[sizeof(int)]; * diff --git a/ccan/alignof/test/run.c b/ccan/alignof/test/run.c index f36113d1..5e3216f1 100644 --- a/ccan/alignof/test/run.c +++ b/ccan/alignof/test/run.c @@ -24,7 +24,7 @@ struct lots_of_types char c5; }; -int main(int argc, char *argv[]) +int main(void) { struct lots_of_types lots_of_types, *lp = malloc(sizeof(*lp)); char c; diff --git a/ccan/array_size/test/compile_fail-function-param.c b/ccan/array_size/test/compile_fail-function-param.c index 48697e04..164c826f 100644 --- a/ccan/array_size/test/compile_fail-function-param.c +++ b/ccan/array_size/test/compile_fail-function-param.c @@ -18,7 +18,7 @@ int check_parameter(const struct foo *array) #endif } -int main(int argc, char *argv[]) +int main(void) { return check_parameter(NULL); } diff --git a/ccan/array_size/test/compile_fail.c b/ccan/array_size/test/compile_fail.c index 37d315f2..9bd65682 100644 --- a/ccan/array_size/test/compile_fail.c +++ b/ccan/array_size/test/compile_fail.c @@ -2,6 +2,8 @@ int main(int argc, char *argv[8]) { + (void)argc; + (void)argv; char array[100]; #ifdef FAIL return ARRAY_SIZE(argv) + ARRAY_SIZE(array); diff --git a/ccan/array_size/test/run.c b/ccan/array_size/test/run.c index 37b4200b..3c4ae189 100644 --- a/ccan/array_size/test/run.c +++ b/ccan/array_size/test/run.c @@ -16,7 +16,7 @@ static int array2_size = ARRAY_SIZE(array2); static int array3_size = ARRAY_SIZE(array3); static int array4_size = ARRAY_SIZE(array4); -int main(int argc, char *argv[]) +int main(void) { plan_tests(8); ok1(array1_size == 1); diff --git a/ccan/asort/_info b/ccan/asort/_info index 28e2faeb..4d59bec1 100644 --- a/ccan/asort/_info +++ b/ccan/asort/_info @@ -31,7 +31,7 @@ * int main(int argc, char *argv[]) * { * bool casefold = false; - * unsigned int i; + * int i; * * if (argc < 2) { * fprintf(stderr, "Usage: %s [-i] ...\n" diff --git a/ccan/asort/test/compile_fail-context-type.c b/ccan/asort/test/compile_fail-context-type.c index 473d1026..aa2340f4 100644 --- a/ccan/asort/test/compile_fail-context-type.c +++ b/ccan/asort/test/compile_fail-context-type.c @@ -1,7 +1,7 @@ #include #include -static int cmp(char *const *a, char *const *b, int *flag) +static int cmp(char *const *a UNNEEDED, char *const *b UNNEEDED, int *flag UNNEEDED) { return 0; } diff --git a/ccan/autodata/autodata.c b/ccan/autodata/autodata.c index d8ea88fe..e8086e3a 100644 --- a/ccan/autodata/autodata.c +++ b/ccan/autodata/autodata.c @@ -11,7 +11,7 @@ void *autodata_get_section(void *start, void *stop, size_t *nump) return start; } -void autodata_free(void *table) +void autodata_free(void *table UNNEEDED) { } #else diff --git a/ccan/build_assert/test/compile_fail-expr.c b/ccan/build_assert/test/compile_fail-expr.c index 109215b8..6322eb35 100644 --- a/ccan/build_assert/test/compile_fail-expr.c +++ b/ccan/build_assert/test/compile_fail-expr.c @@ -1,6 +1,6 @@ #include -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL return BUILD_ASSERT_OR_ZERO(1 == 0); diff --git a/ccan/build_assert/test/compile_fail.c b/ccan/build_assert/test/compile_fail.c index 37d95edd..9fd827d6 100644 --- a/ccan/build_assert/test/compile_fail.c +++ b/ccan/build_assert/test/compile_fail.c @@ -1,6 +1,6 @@ #include -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL BUILD_ASSERT(1 == 0); diff --git a/ccan/build_assert/test/compile_ok.c b/ccan/build_assert/test/compile_ok.c index 4105484d..b4de8b41 100644 --- a/ccan/build_assert/test/compile_ok.c +++ b/ccan/build_assert/test/compile_ok.c @@ -1,6 +1,6 @@ #include -int main(int argc, char *argv[]) +int main(void) { BUILD_ASSERT(1 == 1); return 0; diff --git a/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c b/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c index 41858213..72f9ad1b 100644 --- a/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c +++ b/ccan/build_assert/test/run-BUILD_ASSERT_OR_ZERO.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { plan_tests(1); ok1(BUILD_ASSERT_OR_ZERO(1 == 1) == 0); diff --git a/ccan/cast/_info b/ccan/cast/_info index b09e0344..29128b8d 100644 --- a/ccan/cast/_info +++ b/ccan/cast/_info @@ -24,6 +24,7 @@ * #include * #include * #include + * #include * * // Find char @orig in @str, if @repl, replace them. Return number. * static size_t find_chars(char *str, char orig, char repl) @@ -53,6 +54,9 @@ * { * uint64_t hash; * + * if (argc != 2) { + * fprintf(stderr, "Needs argument\n"); exit(1); + * } * // find_chars wants a non-const string, but doesn't * // need it if repl == 0. * printf("%zu %c's in 'test string'\n", diff --git a/ccan/cast/test/compile_fail-cast_const.c b/ccan/cast/test/compile_fail-cast_const.c index 277f3de1..24ee4b1f 100644 --- a/ccan/cast/test/compile_fail-cast_const.c +++ b/ccan/cast/test/compile_fail-cast_const.c @@ -6,7 +6,7 @@ struct char_struct { char c; }; -int main(int argc, char *argv[]) +int main(void) { char *uc; const diff --git a/ccan/cast/test/compile_fail-cast_const2.c b/ccan/cast/test/compile_fail-cast_const2.c index e671e88e..b780f528 100644 --- a/ccan/cast/test/compile_fail-cast_const2.c +++ b/ccan/cast/test/compile_fail-cast_const2.c @@ -6,7 +6,7 @@ struct char_struct { char c; }; -int main(int argc, char *argv[]) +int main(void) { char **uc; const diff --git a/ccan/cast/test/compile_fail-cast_const3.c b/ccan/cast/test/compile_fail-cast_const3.c index e958e2dd..ac7462c5 100644 --- a/ccan/cast/test/compile_fail-cast_const3.c +++ b/ccan/cast/test/compile_fail-cast_const3.c @@ -6,7 +6,7 @@ struct char_struct { char c; }; -int main(int argc, char *argv[]) +int main(void) { char ***uc; const diff --git a/ccan/cast/test/compile_fail-cast_signed-const.c b/ccan/cast/test/compile_fail-cast_signed-const.c index 9971dc8e..26bf8974 100644 --- a/ccan/cast/test/compile_fail-cast_signed-const.c +++ b/ccan/cast/test/compile_fail-cast_signed-const.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { unsigned char *uc; #ifdef FAIL diff --git a/ccan/cast/test/compile_fail-cast_signed-sizesame.c b/ccan/cast/test/compile_fail-cast_signed-sizesame.c index 2bc40b2f..b6bbd283 100644 --- a/ccan/cast/test/compile_fail-cast_signed-sizesame.c +++ b/ccan/cast/test/compile_fail-cast_signed-sizesame.c @@ -6,7 +6,7 @@ struct char_struct { char c; }; -int main(int argc, char *argv[]) +int main(void) { unsigned char *uc; #ifdef FAIL diff --git a/ccan/cast/test/compile_fail-cast_signed.c b/ccan/cast/test/compile_fail-cast_signed.c index 66bcc0a1..7661bac4 100644 --- a/ccan/cast/test/compile_fail-cast_signed.c +++ b/ccan/cast/test/compile_fail-cast_signed.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { unsigned char *uc; #ifdef FAIL diff --git a/ccan/cast/test/compile_fail-cast_static-2.c b/ccan/cast/test/compile_fail-cast_static-2.c index 8a120253..dae0231e 100644 --- a/ccan/cast/test/compile_fail-cast_static-2.c +++ b/ccan/cast/test/compile_fail-cast_static-2.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { char *c; #ifdef FAIL diff --git a/ccan/cast/test/compile_fail-cast_static-3.c b/ccan/cast/test/compile_fail-cast_static-3.c index 6296b752..7cd52fc7 100644 --- a/ccan/cast/test/compile_fail-cast_static-3.c +++ b/ccan/cast/test/compile_fail-cast_static-3.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { char *c; #ifdef FAIL diff --git a/ccan/cast/test/compile_fail-cast_static.c b/ccan/cast/test/compile_fail-cast_static.c index a4ebf61b..91d0940b 100644 --- a/ccan/cast/test/compile_fail-cast_static.c +++ b/ccan/cast/test/compile_fail-cast_static.c @@ -1,7 +1,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { long c; #ifdef FAIL diff --git a/ccan/cast/test/compile_ok-static.c b/ccan/cast/test/compile_ok-static.c index 98b667e8..a7c65725 100644 --- a/ccan/cast/test/compile_ok-static.c +++ b/ccan/cast/test/compile_ok-static.c @@ -6,5 +6,6 @@ static char *p = cast_const(char *, (const char *)"hello"); int main(int argc, char *argv[]) { + (void)argc; return p[0] == argv[0][0]; } diff --git a/ccan/cdump/_info b/ccan/cdump/_info index 02ba19b5..c79d013b 100644 --- a/ccan/cdump/_info +++ b/ccan/cdump/_info @@ -29,7 +29,8 @@ * { * char *code, *problems; * struct cdump_definitions *defs; - * int i, j; + * int i; + * size_t j; * * // Read code from stdin. * code = grab_file(NULL, NULL); diff --git a/ccan/cdump/cdump.c b/ccan/cdump/cdump.c index 85c818a6..7e42dbd7 100644 --- a/ccan/cdump/cdump.c +++ b/ccan/cdump/cdump.c @@ -213,7 +213,7 @@ static struct cdump_type *get_type(struct cdump_definitions *defs, enum cdump_type_kind kind, const char *name) { - cdump_map_t *m; + cdump_map_t *m = (void *)0x1L; /* Shouldn't be used */ struct cdump_type *t; switch (kind) { diff --git a/ccan/check_type/test/compile_fail-check_type.c b/ccan/check_type/test/compile_fail-check_type.c index fe7d6a23..4c22c65a 100644 --- a/ccan/check_type/test/compile_fail-check_type.c +++ b/ccan/check_type/test/compile_fail-check_type.c @@ -2,6 +2,8 @@ int main(int argc, char *argv[]) { + (void)argc; + (void)argv; #ifdef FAIL check_type(argc, char); #endif diff --git a/ccan/check_type/test/compile_fail-check_type_unsigned.c b/ccan/check_type/test/compile_fail-check_type_unsigned.c index 574d4aeb..795e7606 100644 --- a/ccan/check_type/test/compile_fail-check_type_unsigned.c +++ b/ccan/check_type/test/compile_fail-check_type_unsigned.c @@ -2,6 +2,8 @@ int main(int argc, char *argv[]) { + (void)argc; + (void)argv; #ifdef FAIL #if HAVE_TYPEOF check_type(argc, unsigned int); diff --git a/ccan/check_type/test/compile_fail-check_types_match.c b/ccan/check_type/test/compile_fail-check_types_match.c index cbd6e9bc..fb83738b 100644 --- a/ccan/check_type/test/compile_fail-check_types_match.c +++ b/ccan/check_type/test/compile_fail-check_types_match.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { unsigned char x = argc; + (void)argv; #ifdef FAIL check_types_match(argc, x); #endif diff --git a/ccan/check_type/test/run.c b/ccan/check_type/test/run.c index 83b903c0..09fd3634 100644 --- a/ccan/check_type/test/run.c +++ b/ccan/check_type/test/run.c @@ -5,6 +5,7 @@ int main(int argc, char *argv[]) { int x = 0, y = 0; + (void)argv; plan_tests(9); ok1(check_type(argc, int) == 0); diff --git a/ccan/compiler/_info b/ccan/compiler/_info index d60dff4d..12cb2475 100644 --- a/ccan/compiler/_info +++ b/ccan/compiler/_info @@ -41,7 +41,7 @@ * va_end(ap); * } * - * int main(int argc, char *argv[]) + * int main(int argc, char *argv[] UNNEEDED) * { * if (argc != 1) { * logger(3, "Don't want %i arguments!\n", argc-1); diff --git a/ccan/compiler/test/compile_fail-printf.c b/ccan/compiler/test/compile_fail-printf.c index 8f34ae5a..7664f65d 100644 --- a/ccan/compiler/test/compile_fail-printf.c +++ b/ccan/compiler/test/compile_fail-printf.c @@ -2,9 +2,11 @@ static void PRINTF_FMT(2,3) my_printf(int x, const char *fmt, ...) { + (void)x; + (void)fmt; } -int main(int argc, char *argv[]) +int main(void) { unsigned int i = 0; diff --git a/ccan/compiler/test/run-is_compile_constant.c b/ccan/compiler/test/run-is_compile_constant.c index a66f2e13..c914c683 100644 --- a/ccan/compiler/test/run-is_compile_constant.c +++ b/ccan/compiler/test/run-is_compile_constant.c @@ -3,6 +3,8 @@ int main(int argc, char *argv[]) { + (void)argc; + (void)argv; plan_tests(2); ok1(!IS_COMPILE_CONSTANT(argc)); diff --git a/ccan/container_of/_info b/ccan/container_of/_info index d50094bc..b1160522 100644 --- a/ccan/container_of/_info +++ b/ccan/container_of/_info @@ -26,17 +26,19 @@ * struct timer timer; * }; * - * static void register_timer(struct timer *timer) - * { - * //... - * } - * * static void my_timer_callback(struct timer *timer) * { * struct info *info = container_of(timer, struct info, timer); * printf("my_stuff is %u\n", info->my_stuff); * } * + * static void register_timer(struct timer *timer) + * { + * (void)timer; + * (void)my_timer_callback; + * //... + * } + * * int main(void) * { * struct info info = { .my_stuff = 1 }; diff --git a/ccan/container_of/test/compile_fail-bad-type.c b/ccan/container_of/test/compile_fail-bad-type.c index b7a14593..55a911a1 100644 --- a/ccan/container_of/test/compile_fail-bad-type.c +++ b/ccan/container_of/test/compile_fail-bad-type.c @@ -6,7 +6,7 @@ struct foo { char b; }; -int main(int argc, char *argv[]) +int main(void) { struct foo foo = { .a = 1, .b = 2 }; int *intp = &foo.a; diff --git a/ccan/container_of/test/compile_fail-types.c b/ccan/container_of/test/compile_fail-types.c index cae1c7ab..fbb97a9e 100644 --- a/ccan/container_of/test/compile_fail-types.c +++ b/ccan/container_of/test/compile_fail-types.c @@ -6,7 +6,7 @@ struct foo { char b; }; -int main(int argc, char *argv[]) +int main(void) { struct foo foo = { .a = 1, .b = 2 }, *foop; int *intp = &foo.a; diff --git a/ccan/container_of/test/compile_fail-var-types.c b/ccan/container_of/test/compile_fail-var-types.c index f254d921..ecdd9091 100644 --- a/ccan/container_of/test/compile_fail-var-types.c +++ b/ccan/container_of/test/compile_fail-var-types.c @@ -6,7 +6,7 @@ struct foo { char b; }; -int main(int argc, char *argv[]) +int main(void) { struct foo foo = { .a = 1, .b = 2 }, *foop; int *intp = &foo.a; diff --git a/ccan/container_of/test/run.c b/ccan/container_of/test/run.c index 18207f60..32557295 100644 --- a/ccan/container_of/test/run.c +++ b/ccan/container_of/test/run.c @@ -6,7 +6,7 @@ struct foo { char b; }; -int main(int argc, char *argv[]) +int main(void) { struct foo foo = { .a = 1, .b = 2 }; int *intp = &foo.a; diff --git a/ccan/cpuid/cpuid.c b/ccan/cpuid/cpuid.c index 9a42d83e..4510def8 100644 --- a/ccan/cpuid/cpuid.c +++ b/ccan/cpuid/cpuid.c @@ -237,7 +237,7 @@ cputype_t cpuid_get_cpu_type(void) uint32_t i; get_cpuid(CPUID_VENDORID, &i, &u.bufu32[0], &u.bufu32[2], &u.bufu32[1]); - for (i = 0; i < sizeof(c_cpunames) / sizeof(c_cpunames); ++i) { + for (i = 0; i < sizeof(c_cpunames) / sizeof(c_cpunames[0]); ++i) { if (strncmp(c_cpunames[i], u.buf, 12) == 0) { cputype = (cputype_t)i; break; diff --git a/ccan/crypto/siphash24/siphash24.c b/ccan/crypto/siphash24/siphash24.c index d250de32..20daa74d 100644 --- a/ccan/crypto/siphash24/siphash24.c +++ b/ccan/crypto/siphash24/siphash24.c @@ -45,6 +45,7 @@ static void check_siphash24(struct siphash24_ctx *ctx) static bool alignment_ok(const void *p, size_t n) { #if HAVE_UNALIGNED_ACCESS + (void)p; (void)n; return true; #else return ((size_t)p % n == 0); diff --git a/ccan/endian/test/run.c b/ccan/endian/test/run.c index a00fce74..9bf47f13 100644 --- a/ccan/endian/test/run.c +++ b/ccan/endian/test/run.c @@ -3,7 +3,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { union { uint64_t u64; diff --git a/ccan/err/test/run.c b/ccan/err/test/run.c index 242e93f8..aeaa3750 100644 --- a/ccan/err/test/run.c +++ b/ccan/err/test/run.c @@ -15,6 +15,7 @@ int main(int argc, char *argv[]) int pfd[2]; const char *base; + (void)argc; plan_tests(24); err_set_progname(argv[0]); @@ -27,7 +28,8 @@ int main(int argc, char *argv[]) base = argv[0]; /* Test err() in child */ - pipe(pfd); + if (pipe(pfd)) + abort(); fflush(stdout); if (fork()) { char buffer[BUFFER_MAX+1]; @@ -59,7 +61,8 @@ int main(int argc, char *argv[]) } /* Test errx() in child */ - pipe(pfd); + if (pipe(pfd)) + abort(); fflush(stdout); if (fork()) { char buffer[BUFFER_MAX+1]; @@ -89,7 +92,8 @@ int main(int argc, char *argv[]) /* Test warn() in child */ - pipe(pfd); + if (pipe(pfd)) + abort(); fflush(stdout); if (fork()) { char buffer[BUFFER_MAX+1]; @@ -121,7 +125,8 @@ int main(int argc, char *argv[]) } /* Test warnx() in child */ - pipe(pfd); + if (pipe(pfd)) + abort(); fflush(stdout); if (fork()) { char buffer[BUFFER_MAX+1]; diff --git a/ccan/foreach/test/run-nested.c b/ccan/foreach/test/run-nested.c index aa20437e..0bb21c98 100644 --- a/ccan/foreach/test/run-nested.c +++ b/ccan/foreach/test/run-nested.c @@ -44,7 +44,7 @@ static int count_iters(void) int main(void) { - int i, j, sum, max_iters; + int i, j, sum, max_iters = 0 /* keep gcc happy */; const char *istr, *jstr; plan_tests(13); diff --git a/ccan/htable/_info b/ccan/htable/_info index 7e06c386..a3bb76db 100644 --- a/ccan/htable/_info +++ b/ccan/htable/_info @@ -36,6 +36,7 @@ * // Wrapper for rehash function pointer. * static size_t rehash(const void *e, void *unused) * { + * (void)unused; * return hash_string(((struct name_to_digit *)e)->name); * } * @@ -64,7 +65,7 @@ * int main(int argc, char *argv[]) * { * struct htable ht; - * unsigned int i; + * int i; * unsigned long val; * * if (argc < 2) @@ -73,7 +74,7 @@ * * // Create and populate hash table. * htable_init(&ht, rehash, NULL); - * for (i = 0; i < sizeof(map)/sizeof(map[0]); i++) + * for (i = 0; i < (int)(sizeof(map)/sizeof(map[0])); i++) * htable_add(&ht, hash_string(map[i].name), &map[i]); * * // Add any aliases to the hash table. diff --git a/ccan/htable/htable.h b/ccan/htable/htable.h index 61ed9170..9845388e 100644 --- a/ccan/htable/htable.h +++ b/ccan/htable/htable.h @@ -35,6 +35,7 @@ struct htable { * // For simplicity's sake, say hash value is contents of elem. * static size_t rehash(const void *elem, void *unused) * { + * (void)unused; * return *(size_t *)elem; * } * static struct htable ht = HTABLE_INITIALIZER(ht, rehash, NULL); diff --git a/ccan/htable/test/run-copy.c b/ccan/htable/test/run-copy.c index 02d5bbe4..d111495a 100644 --- a/ccan/htable/test/run-copy.c +++ b/ccan/htable/test/run-copy.c @@ -6,7 +6,7 @@ #define NUM_VALS 512 -static size_t hash(const void *elem, void *unused) +static size_t hash(const void *elem, void *unused UNNEEDED) { size_t h = *(uint64_t *)elem / 2; return h; @@ -17,7 +17,7 @@ static bool cmp(const void *candidate, void *ptr) return *(const uint64_t *)candidate == *(const uint64_t *)ptr; } -int main(int argc, char *argv[]) +int main(void) { struct htable ht, ht2; uint64_t val[NUM_VALS], i; diff --git a/ccan/htable/test/run-size.c b/ccan/htable/test/run-size.c index c92401c3..1a2f5cdd 100644 --- a/ccan/htable/test/run-size.c +++ b/ccan/htable/test/run-size.c @@ -8,13 +8,13 @@ /* We use the number divided by two as the hash (for lots of collisions). */ -static size_t hash(const void *elem, void *unused) +static size_t hash(const void *elem, void *unused UNNEEDED) { size_t h = *(uint64_t *)elem / 2; return h; } -int main(int argc, char *argv[]) +int main(void) { struct htable ht; uint64_t val[NUM_VALS]; diff --git a/ccan/htable/test/run-type-int.c b/ccan/htable/test/run-type-int.c index 66346d0c..7b71815f 100644 --- a/ccan/htable/test/run-type-int.c +++ b/ccan/htable/test/run-type-int.c @@ -88,7 +88,7 @@ static void del_vals(struct htable_obj *ht, } static void del_vals_bykey(struct htable_obj *ht, - const struct obj val[], unsigned int num) + const struct obj val[] UNNEEDED, unsigned int num) { unsigned int i; @@ -112,7 +112,7 @@ static bool check_mask(struct htable *ht, const struct obj val[], unsigned num) return true; } -int main(int argc, char *argv[]) +int main(void) { unsigned int i; struct htable_obj ht, ht2; diff --git a/ccan/htable/test/run-type.c b/ccan/htable/test/run-type.c index e1a78f49..a3616a5a 100644 --- a/ccan/htable/test/run-type.c +++ b/ccan/htable/test/run-type.c @@ -83,7 +83,7 @@ static void del_vals(struct htable_obj *ht, } static void del_vals_bykey(struct htable_obj *ht, - const struct obj val[], unsigned int num) + const struct obj val[] UNNEEDED, unsigned int num) { unsigned int i; @@ -107,7 +107,7 @@ static bool check_mask(struct htable *ht, const struct obj val[], unsigned num) return true; } -int main(int argc, char *argv[]) +int main(void) { unsigned int i; struct htable_obj ht, ht2; diff --git a/ccan/htable/test/run-zero-hash-first-entry.c b/ccan/htable/test/run-zero-hash-first-entry.c index fdd18569..3a1a939e 100644 --- a/ccan/htable/test/run-zero-hash-first-entry.c +++ b/ccan/htable/test/run-zero-hash-first-entry.c @@ -8,7 +8,7 @@ struct data { }; /* Hash is simply key itself. */ -static size_t hash(const void *e, void *unused) +static size_t hash(const void *e, void *unused UNNEEDED) { struct data *d = (struct data *)e; diff --git a/ccan/htable/test/run.c b/ccan/htable/test/run.c index 09cde890..46514c72 100644 --- a/ccan/htable/test/run.c +++ b/ccan/htable/test/run.c @@ -10,7 +10,7 @@ /* We use the number divided by two as the hash (for lots of collisions), plus set all the higher bits so we can detect if they don't get masked out. */ -static size_t hash(const void *elem, void *unused) +static size_t hash(const void *elem, void *unused UNNEEDED) { size_t h = *(uint64_t *)elem / 2; h |= -1UL << NUM_BITS; @@ -95,7 +95,7 @@ static bool check_mask(struct htable *ht, uint64_t val[], unsigned num) return true; } -int main(int argc, char *argv[]) +int main(void) { unsigned int i, weight; uintptr_t perfect_bit; diff --git a/ccan/ilog/test/run-out-of-line.c b/ccan/ilog/test/run-out-of-line.c index 48205d38..a0918d75 100644 --- a/ccan/ilog/test/run-out-of-line.c +++ b/ccan/ilog/test/run-out-of-line.c @@ -19,7 +19,7 @@ static int test_ilog64(uint64_t _v){ #define NTRIALS (64) -int main(int _argc,const char *_argv[]){ +int main(void){ int i; int j; int (*il32)(uint32_t) = ilog32; diff --git a/ccan/ilog/test/run.c b/ccan/ilog/test/run.c index bda59f92..00824ac3 100644 --- a/ccan/ilog/test/run.c +++ b/ccan/ilog/test/run.c @@ -19,7 +19,7 @@ static int test_ilog64(uint64_t _v){ #define NTRIALS (64) -int main(int _argc,const char *_argv[]){ +int main(void){ int i; int j; /*This is how many tests you plan to run.*/ diff --git a/ccan/io/io.h b/ccan/io/io.h index 9316dd18..e24beec4 100644 --- a/ccan/io/io.h +++ b/ccan/io/io.h @@ -47,7 +47,8 @@ struct io_conn; * int fd[2]; * struct io_conn *conn; * - * pipe(fd); + * if (pipe(fd) != 0) + * exit(1); * conn = io_new_conn(NULL, fd[0], conn_init, (const char *)"hi!"); * if (!conn) * exit(1); @@ -653,11 +654,11 @@ int io_conn_fd(const struct io_conn *conn); * io_time_override - override the normal call for time. * @nowfn: the function to call. * - * io usually uses time_now() internally, but this forces it + * io usually uses time_mono() internally, but this forces it * to use your function (eg. for debugging). Returns the old * one. */ -struct timeabs (*io_time_override(struct timeabs (*now)(void)))(void); +struct timemono (*io_time_override(struct timemono (*now)(void)))(void); /** * io_set_debug - set synchronous mode on a connection. diff --git a/ccan/io/poll.c b/ccan/io/poll.c index cddc3cac..36af33ef 100644 --- a/ccan/io/poll.c +++ b/ccan/io/poll.c @@ -16,11 +16,11 @@ static struct pollfd *pollfds = NULL; static struct fd **fds = NULL; static LIST_HEAD(closing); static LIST_HEAD(always); -static struct timeabs (*nowfn)(void) = time_now; +static struct timemono (*nowfn)(void) = time_mono; -struct timeabs (*io_time_override(struct timeabs (*now)(void)))(void) +struct timemono (*io_time_override(struct timemono (*now)(void)))(void) { - struct timeabs (*old)(void) = nowfn; + struct timemono (*old)(void) = nowfn; nowfn = now; return old; } @@ -262,7 +262,7 @@ void *io_loop(struct timers *timers, struct timer **expired) assert(num_waiting); if (timers) { - struct timeabs now, first; + struct timemono now, first; now = nowfn(); @@ -274,7 +274,7 @@ void *io_loop(struct timers *timers, struct timer **expired) /* Now figure out how long to wait for the next one. */ if (timer_earliest(timers, &first)) { uint64_t next; - next = time_to_msec(time_between(first, now)); + next = time_to_msec(timemono_between(first, now)); if (next < INT_MAX) ms_timeout = next; else diff --git a/ccan/io/test/run-01-start-finish.c b/ccan/io/test/run-01-start-finish.c index eb12e948..04952db8 100644 --- a/ccan/io/test/run-01-start-finish.c +++ b/ccan/io/test/run-01-start-finish.c @@ -69,7 +69,7 @@ static int make_listen_fd(const char *port, struct addrinfo **info) int main(void) { int state = 0; - struct addrinfo *addrinfo; + struct addrinfo *addrinfo = NULL; struct io_listener *l; int fd; diff --git a/ccan/io/test/run-02-read.c b/ccan/io/test/run-02-read.c index e25bbbb4..74cb2f02 100644 --- a/ccan/io/test/run-02-read.c +++ b/ccan/io/test/run-02-read.c @@ -71,7 +71,7 @@ static int make_listen_fd(const char *port, struct addrinfo **info) int main(void) { struct data *d = malloc(sizeof(*d)); - struct addrinfo *addrinfo; + struct addrinfo *addrinfo = NULL; struct io_listener *l; int fd, status; diff --git a/ccan/io/test/run-15-timeout.c b/ccan/io/test/run-15-timeout.c index 5709ddaa..a4ab23ad 100644 --- a/ccan/io/test/run-15-timeout.c +++ b/ccan/io/test/run-15-timeout.c @@ -47,8 +47,7 @@ static struct io_plan *init_conn(struct io_conn *conn, struct data *d) d->conn = conn; io_set_finish(conn, finish_ok, d); - timer_add(&d->timers, &d->timer, - timeabs_add(time_now(), time_from_usec(d->timeout_usec))); + timer_addrel(&d->timers, &d->timer, time_from_usec(d->timeout_usec)); return io_read(conn, d->buf, sizeof(d->buf), no_timeout, d); } @@ -97,7 +96,7 @@ int main(void) plan_tests(21); d->state = 0; d->timeout_usec = 100000; - timers_init(&d->timers, time_now()); + timers_init(&d->timers, time_mono()); timer_init(&d->timer); fd = make_listen_fd(PORT, &addrinfo); ok1(fd >= 0); @@ -131,7 +130,7 @@ int main(void) /* One element, d->timer. */ ok1(expired == &d->timer); - ok1(!timers_expire(&d->timers, time_now())); + ok1(!timers_expire(&d->timers, time_mono())); ok1(d->state == 1); io_close(d->conn); diff --git a/ccan/io/test/run-20-io_time_override.c b/ccan/io/test/run-20-io_time_override.c index bf493c99..c0b607a7 100644 --- a/ccan/io/test/run-20-io_time_override.c +++ b/ccan/io/test/run-20-io_time_override.c @@ -45,9 +45,9 @@ static int make_listen_fd(const char *port, struct addrinfo **info) return fd; } -static struct timeabs fake_time; +static struct timemono fake_time; -static struct timeabs get_fake_time(void) +static struct timemono get_fake_time(void) { return fake_time; } @@ -63,12 +63,12 @@ int main(void) /* This is how many tests you plan to run */ plan_tests(7); - fake_time = time_now(); + fake_time = time_mono(); timers_init(&timers, fake_time); timer_init(&timer); - timer_add(&timers, &timer, - timeabs_add(fake_time, time_from_sec(1000))); + timer_addmono(&timers, &timer, + timemono_add(fake_time, time_from_sec(1000))); fd = make_listen_fd(PORT, &addrinfo); freeaddrinfo(addrinfo); @@ -77,12 +77,12 @@ int main(void) ok1(l); fake_time.ts.tv_sec += 1000; - ok1(io_time_override(get_fake_time) == time_now); + ok1(io_time_override(get_fake_time) == time_mono); ok1(io_loop(&timers, &expired) == NULL); ok1(expired == &timer); ok1(!timers_expire(&timers, fake_time)); - ok1(io_time_override(time_now) == get_fake_time); + ok1(io_time_override(time_mono) == get_fake_time); io_close_listener(l); timers_cleanup(&timers); diff --git a/ccan/isaac/test/run.c b/ccan/isaac/test/run.c index 81a46bc2..c7ea4f97 100644 --- a/ccan/isaac/test/run.c +++ b/ccan/isaac/test/run.c @@ -134,7 +134,7 @@ static const uint32_t STATEVEC[ISAAC_SZ<<1]={ 0x46D95CA5, 0xC54CD95B, 0x9D855E89, 0x4BB5AF29 }; -int main(int _argc,const char *_argv[]){ +int main(void){ isaac_ctx isaac; int i; int j; diff --git a/ccan/isaac/test/run64.c b/ccan/isaac/test/run64.c index db2b4d35..de9bef49 100644 --- a/ccan/isaac/test/run64.c +++ b/ccan/isaac/test/run64.c @@ -262,7 +262,7 @@ static const uint64_t STATEVEC64[ISAAC64_SZ<<1]={ 0x1877B51E57A764D5ULL, 0x001F837CC7350524ULL }; -int main(int _argc,const char *_argv[]){ +int main(void){ isaac64_ctx isaac64; int i; int j; diff --git a/ccan/jmap/tools/Makefile b/ccan/jmap/tools/Makefile index b9f07b98..efb46698 100644 --- a/ccan/jmap/tools/Makefile +++ b/ccan/jmap/tools/Makefile @@ -1,6 +1,6 @@ CFLAGS=-Wall -Werror -O3 -I../../.. -LDFLAGS=-lJudy +LDLIBS=-lJudy speed: speed.o -speed.o: speed.c ../jmap.h ../jmap_type.h ../jmap.c +speed.o: speed.c ../jmap.h diff --git a/ccan/jmap/tools/speed.c b/ccan/jmap/tools/speed.c index d2ecd6f6..6cd6d479 100644 --- a/ccan/jmap/tools/speed.c +++ b/ccan/jmap/tools/speed.c @@ -1,38 +1,33 @@ /* Simple speed tests for jmap. */ -#include #include +#include #include #include -#include #include -#include struct object { /* Some contents. Doubles as consistency check. */ struct object *self; }; +struct jmap_obj { + JMAP_MEMBERS(unsigned int, struct object *); +}; + /* Nanoseconds per operation */ -static size_t normalize(const struct timeval *start, - const struct timeval *stop, +static size_t normalize(const struct timeabs *start, + const struct timeabs *stop, unsigned int num) { - struct timeval diff; - - timersub(stop, start, &diff); - - /* Floating point is more accurate here. */ - return (double)(diff.tv_sec * 1000000 + diff.tv_usec) - / num * 1000; + return time_to_nsec(time_divide(time_between(*stop, *start), num)); } -JMAP_DEFINE_UINTIDX_TYPE(struct object, obj); - int main(int argc, char *argv[]) { struct object *objs; - size_t i, j, num; - struct timeval start, stop; + unsigned int i, j; + size_t num; + struct timeabs start, stop; struct jmap_obj *jmap; num = argv[1] ? atoi(argv[1]) : 1000000; @@ -42,110 +37,110 @@ int main(int argc, char *argv[]) objs[i].self = &objs[i]; } - jmap = jmap_obj_new(); + jmap = jmap_new(struct jmap_obj); printf("Initial insert: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - jmap_obj_add(jmap, i, objs[i].self); - gettimeofday(&stop, NULL); + jmap_add(jmap, i, objs[i].self); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Initial lookup (match): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - if (jmap_obj_get(jmap, i)->self != objs[i].self) + if (jmap_get(jmap, i)->self != objs[i].self) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Initial lookup (miss): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - if (jmap_obj_get(jmap, i+num)) + if (jmap_get(jmap, i+num)) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); /* Lookups in order are very cache-friendly for judy; try random */ printf("Initial lookup (random): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num) - if (jmap_obj_get(jmap, j)->self != &objs[j]) + if (jmap_get(jmap, j)->self != &objs[j]) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Initial delete all: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - jmap_obj_del(jmap, i); - gettimeofday(&stop, NULL); + jmap_del(jmap, i); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Initial re-inserting: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - jmap_obj_add(jmap, i, objs[i].self); - gettimeofday(&stop, NULL); + jmap_add(jmap, i, objs[i].self); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Deleting first half: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i+=2) - jmap_obj_del(jmap, i); - gettimeofday(&stop, NULL); + jmap_del(jmap, i); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Adding (a different) half: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i+=2) - jmap_obj_add(jmap, num+i, objs[i].self); - gettimeofday(&stop, NULL); + jmap_add(jmap, num+i, objs[i].self); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Lookup after half-change (match): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 1; i < num; i+=2) - if (jmap_obj_get(jmap, i)->self != objs[i].self) + if (jmap_get(jmap, i)->self != objs[i].self) abort(); for (i = 0; i < num; i+=2) - if (jmap_obj_get(jmap, i+num)->self != objs[i].self) + if (jmap_get(jmap, i+num)->self != objs[i].self) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Lookup after half-change(miss): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - if (jmap_obj_get(jmap, i+num*2)) + if (jmap_get(jmap, i+num*2)) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); /* Hashtables with delete markers can fill with markers over time. * so do some changes to see how it operates in long-term. */ printf("Details: churning first time\n"); for (i = 1; i < num; i+=2) { - if (!jmap_obj_del(jmap, i)) + if (!jmap_del(jmap, i)) abort(); - jmap_obj_add(jmap, i, objs[i].self); + jmap_add(jmap, i, objs[i].self); } for (i = 0; i < num; i+=2) { - if (!jmap_obj_del(jmap, i+num)) + if (!jmap_del(jmap, i+num)) abort(); - jmap_obj_add(jmap, i, objs[i].self); + jmap_add(jmap, i, objs[i].self); } for (i = 1; i < 5; i++) { printf("Churning %s time: ", @@ -154,84 +149,88 @@ int main(int argc, char *argv[]) : i == 3 ? "fourth" : "fifth"); fflush(stdout); - gettimeofday(&start, NULL); + + start = time_now(); for (j = 0; j < num; j++) { - if (!jmap_obj_del(jmap, num*(i-1)+j)) + if (!jmap_del(jmap, num*(i-1)+j)) abort(); - jmap_obj_add(jmap, num*i+j, &objs[j]); + jmap_add(jmap, num*i+j, &objs[j]); } - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); } /* Spread out the keys more to try to make it harder. */ printf("Details: reinserting with spread\n"); for (i = 0; i < num; i++) { - if (!jmap_obj_del(jmap, num*4 + i)) + if (!jmap_del(jmap, num*4 + i)) abort(); - jmap_obj_add(jmap, num * 5 + i * 9, objs[i].self); + jmap_add(jmap, num * 5 + i * 9, objs[i].self); } - if (jmap_obj_popcount(jmap, 0, -1) != num) + if (jmap_popcount(jmap, 0, -1) != num) abort(); printf("Lookup after churn & spread (match): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - if (jmap_obj_get(jmap, num * 5 + i * 9)->self != objs[i].self) { + if (jmap_get(jmap, num * 5 + i * 9)->self != objs[i].self) { printf("i =%u\n", i); abort(); } - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Lookup after churn & spread (miss): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i++) - if (jmap_obj_get(jmap, num * 6 + i * 9)) + if (jmap_get(jmap, num * 6 + i * 9)) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Lookup after churn & spread (random): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0, j = 0; i < num; i++, j = (j + 10007) % num) - if (jmap_obj_get(jmap, num * 5 + j * 9)->self != &objs[j]) + if (jmap_get(jmap, num * 5 + j * 9)->self != &objs[j]) abort(); - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Lookup after churn & spread (half-random): "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0, j = 0; i < num/2; i++, j = (j + 10007) % num) { - if (jmap_obj_get(jmap, num * 5 + j * 9)->self != &objs[j]) + if (jmap_get(jmap, num * 5 + j * 9)->self != &objs[j]) abort(); - if (jmap_obj_get(jmap, num * 5 + (j + 1) * 9)->self != &objs[j+1]) + if (jmap_get(jmap, num * 5 + (j + 1) * 9)->self != &objs[j+1]) abort(); } - gettimeofday(&stop, NULL); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Deleting half after churn & spread: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i+=2) - jmap_obj_del(jmap, num * 5 + i * 9); - gettimeofday(&stop, NULL); + jmap_del(jmap, num * 5 + i * 9); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); printf("Adding (a different) half after churn & spread: "); fflush(stdout); - gettimeofday(&start, NULL); + start = time_now(); for (i = 0; i < num; i+=2) - jmap_obj_add(jmap, num * 6 + i * 9, objs[i].self); - gettimeofday(&stop, NULL); + jmap_add(jmap, num * 6 + i * 9, objs[i].self); + stop = time_now(); printf(" %zu ns\n", normalize(&start, &stop, num)); + jmap_free(jmap); + free (objs); + return 0; } diff --git a/ccan/likely/test/run-debug.c b/ccan/likely/test/run-debug.c index 83f22afa..72015ee4 100644 --- a/ccan/likely/test/run-debug.c +++ b/ccan/likely/test/run-debug.c @@ -26,7 +26,7 @@ static bool likely_one_unlikely_two(unsigned int val1, unsigned int val2) return false; } -int main(int argc, char *argv[]) +int main(void) { char *bad; diff --git a/ccan/likely/test/run.c b/ccan/likely/test/run.c index fa1dc9f6..28ea7985 100644 --- a/ccan/likely/test/run.c +++ b/ccan/likely/test/run.c @@ -17,7 +17,7 @@ static bool one_seems_unlikely(unsigned int val) return false; } -int main(int argc, char *argv[]) +int main(void) { plan_tests(4); diff --git a/ccan/list/_info b/ccan/list/_info index 60790a99..c4f3e2a0 100644 --- a/ccan/list/_info +++ b/ccan/list/_info @@ -31,7 +31,7 @@ * { * struct parent p; * struct child *c; - * unsigned int i; + * int i; * * if (argc < 2) * errx(1, "Usage: %s parent children...", argv[0]); diff --git a/ccan/list/list.h b/ccan/list/list.h index 0800a0fa..a6b00385 100644 --- a/ccan/list/list.h +++ b/ccan/list/list.h @@ -291,6 +291,21 @@ static inline bool list_empty_nodebug(const struct list_head *h) } #endif +/** + * list_empty_nocheck - is a list empty? + * @h: the list_head + * + * If the list is empty, returns true. This doesn't perform any + * debug check for list consistency, so it can be called without + * locks, racing with the list being modified. This is ok for + * checks where an incorrect result is not an issue (optimized + * bail out path for example). + */ +static inline bool list_empty_nocheck(const struct list_head *h) +{ + return h->n.next == &h->n; +} + /** * list_del - delete an entry from an (unknown) linked list. * @n: the list_node to delete from the list. @@ -701,12 +716,12 @@ static inline void list_prepend_list_(struct list_head *to, * so you can break and continue as normal. * * WARNING! Being the low-level macro that it is, this wrapper doesn't know - * nor care about the type of @i. The only assumtion made is that @i points + * nor care about the type of @i. The only assumption made is that @i points * to a chunk of memory that at some @offset, relative to @i, contains a - * properly filled `struct node_list' which in turn contains pointers to - * memory chunks and it's turtles all the way down. Whith all that in mind + * properly filled `struct list_node' which in turn contains pointers to + * memory chunks and it's turtles all the way down. With all that in mind * remember that given the wrong pointer/offset couple this macro will - * happilly churn all you memory untill SEGFAULT stops it, in other words + * happily churn all you memory until SEGFAULT stops it, in other words * caveat emptor. * * It is worth mentioning that one of legitimate use-cases for that wrapper diff --git a/ccan/list/test/run-CCAN_LIST_DEBUG.c b/ccan/list/test/run-CCAN_LIST_DEBUG.c index 9fcb1d74..b8e5165a 100644 --- a/ccan/list/test/run-CCAN_LIST_DEBUG.c +++ b/ccan/list/test/run-CCAN_LIST_DEBUG.c @@ -17,6 +17,7 @@ static int my_fprintf(FILE *stream, const char *format, ...) { va_list ap; int ret; + (void)stream; va_start(ap, format); ret = vsprintf(printf_buffer, format, ap); va_end(ap); @@ -28,7 +29,7 @@ static int my_fprintf(FILE *stream, const char *format, ...) #include #include -int main(int argc, char *argv[]) +int main(void) { struct list_head list; struct list_node n1; @@ -44,7 +45,7 @@ int main(int argc, char *argv[]) list.n.prev = &n1; /* Aborting version. */ - sprintf(expect, "run-CCAN_LIST_DEBUG.c:50: prev corrupt in node %p (0) of %p\n", + sprintf(expect, "run-CCAN_LIST_DEBUG.c:51: prev corrupt in node %p (0) of %p\n", &list, &list); if (setjmp(aborted) == 0) { assert(list_empty(&list)); diff --git a/ccan/list/test/run-check-corrupt.c b/ccan/list/test/run-check-corrupt.c index 5dd9f9cc..94c2e67e 100644 --- a/ccan/list/test/run-check-corrupt.c +++ b/ccan/list/test/run-check-corrupt.c @@ -16,6 +16,7 @@ static int my_fprintf(FILE *stream, const char *format, ...) { va_list ap; int ret; + (void)stream; va_start(ap, format); ret = vsprintf(printf_buffer, format, ap); va_end(ap); @@ -26,7 +27,7 @@ static int my_fprintf(FILE *stream, const char *format, ...) #include #include -int main(int argc, char *argv[]) +int main(void) { struct list_head list; struct list_node n1; diff --git a/ccan/list/test/run-check-nonconst.c b/ccan/list/test/run-check-nonconst.c index b006a8a2..d3cb652a 100644 --- a/ccan/list/test/run-check-nonconst.c +++ b/ccan/list/test/run-check-nonconst.c @@ -8,7 +8,7 @@ struct child { struct list_node list; }; -int main(int argc, char *argv[]) +int main(void) { struct child c1, c2; struct list_head list = LIST_HEAD_INIT(list); diff --git a/ccan/list/test/run-list_del_from-assert.c b/ccan/list/test/run-list_del_from-assert.c index 05d6cad6..9404b712 100644 --- a/ccan/list/test/run-list_del_from-assert.c +++ b/ccan/list/test/run-list_del_from-assert.c @@ -7,7 +7,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { struct list_head list1, list2; struct list_node n1, n2, n3; diff --git a/ccan/list/test/run-list_prev-list_next.c b/ccan/list/test/run-list_prev-list_next.c index b496f11f..cc61e03a 100644 --- a/ccan/list/test/run-list_prev-list_next.c +++ b/ccan/list/test/run-list_prev-list_next.c @@ -14,7 +14,7 @@ struct child { struct list_node list; }; -int main(int argc, char *argv[]) +int main(void) { struct parent parent; struct child c1, c2, c3; diff --git a/ccan/list/test/run-prepend_list.c b/ccan/list/test/run-prepend_list.c index d382f5a8..fecd4196 100644 --- a/ccan/list/test/run-prepend_list.c +++ b/ccan/list/test/run-prepend_list.c @@ -17,7 +17,7 @@ static bool list_expect(struct list_head *h, ...) return (n->next == &h->n); } -int main(int argc, char *argv[]) +int main(void) { struct list_head h1, h2; struct list_node n[4]; diff --git a/ccan/list/test/run-single-eval.c b/ccan/list/test/run-single-eval.c index f90eed35..db0bffdd 100644 --- a/ccan/list/test/run-single-eval.c +++ b/ccan/list/test/run-single-eval.c @@ -19,7 +19,7 @@ static LIST_HEAD(static_list); #define ref(obj, counter) ((counter)++, (obj)) -int main(int argc, char *argv[]) +int main(void) { struct parent parent; struct child c1, c2, c3, *c, *n; diff --git a/ccan/list/test/run.c b/ccan/list/test/run.c index 7616af6c..5787e456 100644 --- a/ccan/list/test/run.c +++ b/ccan/list/test/run.c @@ -16,7 +16,7 @@ struct child { static LIST_HEAD(static_list); -int main(int argc, char *argv[]) +int main(void) { struct parent parent; struct child c1, c2, c3, x1, *c, *n; diff --git a/ccan/mem/mem.h b/ccan/mem/mem.h index f2c3d5c7..19f69c03 100644 --- a/ccan/mem/mem.h +++ b/ccan/mem/mem.h @@ -250,6 +250,7 @@ static inline void *memcheck_(const void *data, size_t len) #else static inline void *memcheck_(const void *data, size_t len) { + (void)len; return (void *)data; } #endif diff --git a/ccan/noerr/_info b/ccan/noerr/_info index 082c71e6..85f1f6f9 100644 --- a/ccan/noerr/_info +++ b/ccan/noerr/_info @@ -37,7 +37,7 @@ * return false; * } * // A short write means out of space. - * if (ret < strlen(string)) { + * if (ret < (int)strlen(string)) { * unlink(file); * errno = ENOSPC; * return false; diff --git a/ccan/noerr/test/run.c b/ccan/noerr/test/run.c index 48086a24..31fb6740 100644 --- a/ccan/noerr/test/run.c +++ b/ccan/noerr/test/run.c @@ -7,7 +7,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { const char *name = "noerr.file"; int fd; diff --git a/ccan/opt/opt.h b/ccan/opt/opt.h index 690907e5..0d508cf6 100644 --- a/ccan/opt/opt.h +++ b/ccan/opt/opt.h @@ -185,7 +185,7 @@ void opt_register_table(const struct opt_table *table, const char *desc); * string (or see opt_set_alloc) and return false. * * Example: - * static char *explode(const char *optarg, void *unused) + * static char *explode(const char *optarg, void *unused UNNEEDED) * { * errx(1, "BOOM! %s", optarg); * } diff --git a/ccan/opt/test/compile_ok-const-arg.c b/ccan/opt/test/compile_ok-const-arg.c index f1d10da1..a7344347 100644 --- a/ccan/opt/test/compile_ok-const-arg.c +++ b/ccan/opt/test/compile_ok-const-arg.c @@ -4,7 +4,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { opt_register_noarg("-v", opt_version_and_exit, (const char *)"1.2.3", diff --git a/ccan/opt/test/run-add_desc.c b/ccan/opt/test/run-add_desc.c index ded3f880..b559c7f7 100644 --- a/ccan/opt/test/run-add_desc.c +++ b/ccan/opt/test/run-add_desc.c @@ -4,19 +4,19 @@ #include #include -static void show_10(char buf[OPT_SHOW_LEN], const void *arg) +static void show_10(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED) { memset(buf, 'X', 10); buf[10] = '\0'; } -static void show_max(char buf[OPT_SHOW_LEN], const void *arg) +static void show_max(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED) { memset(buf, 'X', OPT_SHOW_LEN); } /* Test add_desc helper. */ -int main(int argc, char *argv[]) +int main(void) { struct opt_table opt; char *ret; diff --git a/ccan/opt/test/run-checkopt.c b/ccan/opt/test/run-checkopt.c index d54a7520..8447f98d 100644 --- a/ccan/opt/test/run-checkopt.c +++ b/ccan/opt/test/run-checkopt.c @@ -53,7 +53,7 @@ static void reset(void) opt_count = opt_num_short = opt_num_short_arg = opt_num_long = 0; } -int main(int argc, char *argv[]) +int main(void) { int exitval; diff --git a/ccan/opt/test/run-consume_words.c b/ccan/opt/test/run-consume_words.c index 9f164656..c1eaf56a 100644 --- a/ccan/opt/test/run-consume_words.c +++ b/ccan/opt/test/run-consume_words.c @@ -5,7 +5,7 @@ #include /* Test consume_words helper. */ -int main(int argc, char *argv[]) +int main(void) { size_t prefix, len; bool start = true; diff --git a/ccan/opt/test/run-helpers.c b/ccan/opt/test/run-helpers.c index 6ec17f58..0a08a85f 100644 --- a/ccan/opt/test/run-helpers.c +++ b/ccan/opt/test/run-helpers.c @@ -52,7 +52,7 @@ static int saved_printf(const char *fmt, ...) return ret; } -static int saved_fprintf(FILE *ignored, const char *fmt, ...) +static int saved_fprintf(FILE *ignored UNNEEDED, const char *fmt, ...) { va_list ap; int ret; diff --git a/ccan/opt/test/run-iter.c b/ccan/opt/test/run-iter.c index e6b13dad..d34fd6dc 100644 --- a/ccan/opt/test/run-iter.c +++ b/ccan/opt/test/run-iter.c @@ -10,7 +10,7 @@ #include /* Test iterators. */ -int main(int argc, char *argv[]) +int main(void) { unsigned j, i, len = 0; const char *p; diff --git a/ccan/opt/test/run-set_alloc.c b/ccan/opt/test/run-set_alloc.c index 6a10d597..1dbb351b 100644 --- a/ccan/opt/test/run-set_alloc.c +++ b/ccan/opt/test/run-set_alloc.c @@ -2,15 +2,15 @@ #include /* Make sure we override these! */ -static void *no_malloc(size_t size) +static void *no_malloc(size_t size UNNEEDED) { abort(); } -static void *no_realloc(void *p, size_t size) +static void *no_realloc(void *p UNNEEDED, size_t size UNNEEDED) { abort(); } -static void no_free(void *p) +static void no_free(void *p UNNEEDED) { abort(); } diff --git a/ccan/opt/test/run-usage.c b/ccan/opt/test/run-usage.c index aec83244..cea678f3 100644 --- a/ccan/opt/test/run-usage.c +++ b/ccan/opt/test/run-usage.c @@ -6,7 +6,7 @@ #include "utils.h" /* Ensure width is sane. */ -static const char *getenv_override(const char *name) +static const char *getenv_override(const char *name UNNEEDED) { return "100"; } @@ -18,13 +18,13 @@ static const char *getenv_override(const char *name) #include #include -static char *my_cb(void *p) +static char *my_cb(void *p UNNEEDED) { return NULL; } /* Test helpers. */ -int main(int argc, char *argv[]) +int main(void) { char *output; char *longname = strdup("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); diff --git a/ccan/opt/test/utils.c b/ccan/opt/test/utils.c index c2967fca..a9bedf2e 100644 --- a/ccan/opt/test/utils.c +++ b/ccan/opt/test/utils.c @@ -8,7 +8,7 @@ #include "utils.h" unsigned int test_cb_called; -char *test_noarg(void *arg) +char *test_noarg(void *arg UNNEEDED) { test_cb_called++; return NULL; diff --git a/ccan/order/order.c b/ccan/order/order.c index 863a8e16..5ff85a98 100644 --- a/ccan/order/order.c +++ b/ccan/order/order.c @@ -24,7 +24,7 @@ const _type *b, \ void *ctx) \ { \ - return _order_##_oname(a, b, int2ptr(0)); \ + (void)ctx; return _order_##_oname(a, b, int2ptr(0)); \ } \ int _order_##_oname##_reverse(const void *a, \ const void *b, \ @@ -36,6 +36,7 @@ const _type *b, \ void *ctx) \ { \ + (void)ctx; \ return _order_##_oname##_reverse(a, b, int2ptr(0)); \ } \ int order_##_oname##_noctx(const void *a, \ diff --git a/ccan/order/test/compile_fail_1.c b/ccan/order/test/compile_fail_1.c index ba63ca1e..3eed7aa6 100644 --- a/ccan/order/test/compile_fail_1.c +++ b/ccan/order/test/compile_fail_1.c @@ -12,7 +12,7 @@ typedef int item_t; typedef struct item item_t; #endif -int main(int argc, char *argv[]) +int main(void) { total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp; _total_order_cb cb1 = total_order_cast(fancy_cmp, diff --git a/ccan/order/test/compile_fail_2.c b/ccan/order/test/compile_fail_2.c index 5a7126d8..595ffcbb 100644 --- a/ccan/order/test/compile_fail_2.c +++ b/ccan/order/test/compile_fail_2.c @@ -12,7 +12,7 @@ typedef int ctx_t; typedef struct cmp_info ctx_t; #endif -int main(int argc, char *argv[]) +int main(void) { total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp; _total_order_cb cb1 = total_order_cast(fancy_cmp, struct item, diff --git a/ccan/order/test/compile_ok.c b/ccan/order/test/compile_ok.c index 33a42042..37cc4e4e 100644 --- a/ccan/order/test/compile_ok.c +++ b/ccan/order/test/compile_ok.c @@ -6,7 +6,7 @@ #include "fancy_cmp.h" -int main(int argc, char *argv[]) +int main(void) { total_order_cb(cb0, struct item, struct cmp_info *) = fancy_cmp; _total_order_cb cb1 = total_order_cast(fancy_cmp, diff --git a/ccan/order/test/run-fancy.c b/ccan/order/test/run-fancy.c index be5ff3f2..5a287c4c 100644 --- a/ccan/order/test/run-fancy.c +++ b/ccan/order/test/run-fancy.c @@ -8,7 +8,7 @@ #include "fancy_cmp.h" -int main(int argc, char *argv[]) +int main(void) { struct item item1 = { .value = 0, diff --git a/ccan/pipecmd/_info b/ccan/pipecmd/_info index 4621d72f..a560bfea 100644 --- a/ccan/pipecmd/_info +++ b/ccan/pipecmd/_info @@ -28,7 +28,8 @@ * char input[12]; * * if (argc == 2) { - * write(STDOUT_FILENO, "hello world\n", 12); + * if (write(STDOUT_FILENO, "hello world\n", 12) != 12) + * exit(1); * exit(0); * } * child = pipecmd(&outputfd, NULL, NULL, argv[0], "ignoredarg", NULL); diff --git a/ccan/pipecmd/pipecmd.c b/ccan/pipecmd/pipecmd.c index e8aec15b..32772a83 100644 --- a/ccan/pipecmd/pipecmd.c +++ b/ccan/pipecmd/pipecmd.c @@ -122,7 +122,10 @@ pid_t pipecmdarr(int *fd_fromchild, int *fd_tochild, int *fd_errfromchild, child_errno_fail: err = errno; - write(execfail[1], &err, sizeof(err)); + /* Gcc's warn-unused-result fail. */ + if (write(execfail[1], &err, sizeof(err))) { + ; + } exit(127); } diff --git a/ccan/ptr_valid/ptr_valid.c b/ccan/ptr_valid/ptr_valid.c index ef95d34f..dc61dd27 100644 --- a/ccan/ptr_valid/ptr_valid.c +++ b/ccan/ptr_valid/ptr_valid.c @@ -246,9 +246,14 @@ static bool check_with_child(struct ptr_valid_batch *batch, return false; } - write(batch->to_child, &p, sizeof(p)); - write(batch->to_child, &size, sizeof(size)); - write(batch->to_child, &is_write, sizeof(is_write)); + if (write(batch->to_child, &p, sizeof(p)) + + write(batch->to_child, &size, sizeof(size)) + + write(batch->to_child, &is_write, sizeof(is_write)) + != sizeof(p) + sizeof(size) + sizeof(is_write)) { + finish_child(batch); + errno = EFAULT; + return false; + } if (read(batch->from_child, &ret, sizeof(ret)) != sizeof(ret)) { finish_child(batch); diff --git a/ccan/ptrint/_info b/ccan/ptrint/_info index 6300a9bc..30170da9 100644 --- a/ccan/ptrint/_info +++ b/ccan/ptrint/_info @@ -29,7 +29,7 @@ * * void (*cb)(void *opaque) = callback; * - * int main(int argc, char *argv[]) + * int main(void) * { * int val = 17; * diff --git a/ccan/read_write_all/_info b/ccan/read_write_all/_info index 20c5e845..0210dff9 100644 --- a/ccan/read_write_all/_info +++ b/ccan/read_write_all/_info @@ -17,7 +17,7 @@ * #include * * #define BUFFER_SIZE 10 - * int main(int argc, char *argv[]) + * int main(void) * { * char buffer[BUFFER_SIZE+1]; * diff --git a/ccan/read_write_all/test/run-read_all.c b/ccan/read_write_all/test/run-read_all.c index 29f81fc7..6e6588d4 100644 --- a/ccan/read_write_all/test/run-read_all.c +++ b/ccan/read_write_all/test/run-read_all.c @@ -17,6 +17,7 @@ static int p2c[2], c2p[2]; static void got_signal(int sig) { char c = 0; + (void)sig; if (write(p2c[1], &c, 1) == 1) sigcount++; } @@ -24,7 +25,7 @@ static void got_signal(int sig) /* < PIPE_BUF *will* be atomic. But > PIPE_BUF only *might* be non-atomic. */ #define BUFSZ (1024*1024) -int main(int argc, char *argv[]) +int main(void) { char *buffer; char c = 0; diff --git a/ccan/read_write_all/test/run-write_all.c b/ccan/read_write_all/test/run-write_all.c index e2baf48d..c789d6b7 100644 --- a/ccan/read_write_all/test/run-write_all.c +++ b/ccan/read_write_all/test/run-write_all.c @@ -19,6 +19,9 @@ static ssize_t write_return; static ssize_t test_write(int fd, const void *buf, size_t count) { + (void)fd; + (void)buf; + if (write_return == 0) { errno = ENOSPC; return 0; @@ -39,7 +42,7 @@ static ssize_t test_write(int fd, const void *buf, size_t count) #define BUFSZ 1024 -int main(int argc, char *argv[]) +int main(void) { char *buffer; diff --git a/ccan/str/_info b/ccan/str/_info index 251d999a..b579525f 100644 --- a/ccan/str/_info +++ b/ccan/str/_info @@ -26,11 +26,11 @@ * * int main(int argc, char *argv[]) * { - * if (argv[1] && streq(argv[1], "--verbose")) + * if (argc > 1 && streq(argv[1], "--verbose")) * printf("verbose set\n"); - * if (argv[1] && strstarts(argv[1], "--")) + * if (argc > 1 && strstarts(argv[1], "--")) * printf("Some option set\n"); - * if (argv[1] && strends(argv[1], "cow-powers")) + * if (argc > 1 && strends(argv[1], "cow-powers")) * printf("Magic option set\n"); * return 0; * } diff --git a/ccan/str/test/compile_fail-STR_MAX_CHARS.c b/ccan/str/test/compile_fail-STR_MAX_CHARS.c index 74448c1b..8e0fd2e2 100644 --- a/ccan/str/test/compile_fail-STR_MAX_CHARS.c +++ b/ccan/str/test/compile_fail-STR_MAX_CHARS.c @@ -4,7 +4,7 @@ struct s { int val; }; -int main(int argc, char *argv[]) +int main(void) { struct s #ifdef FAIL diff --git a/ccan/str/test/compile_fail-isalnum.c b/ccan/str/test/compile_fail-isalnum.c index 930defff..5d989582 100644 --- a/ccan/str/test/compile_fail-isalnum.c +++ b/ccan/str/test/compile_fail-isalnum.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isalnum. diff --git a/ccan/str/test/compile_fail-isalpha.c b/ccan/str/test/compile_fail-isalpha.c index 20051098..33d36553 100644 --- a/ccan/str/test/compile_fail-isalpha.c +++ b/ccan/str/test/compile_fail-isalpha.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isalpha. diff --git a/ccan/str/test/compile_fail-isascii.c b/ccan/str/test/compile_fail-isascii.c index ee55e499..3946e0b3 100644 --- a/ccan/str/test/compile_fail-isascii.c +++ b/ccan/str/test/compile_fail-isascii.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isascii. diff --git a/ccan/str/test/compile_fail-isblank.c b/ccan/str/test/compile_fail-isblank.c index f4cb961d..e14b0d7e 100644 --- a/ccan/str/test/compile_fail-isblank.c +++ b/ccan/str/test/compile_fail-isblank.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF || !HAVE_ISBLANK #error We need typeof to check isblank. diff --git a/ccan/str/test/compile_fail-iscntrl.c b/ccan/str/test/compile_fail-iscntrl.c index bc741465..f9abf1dc 100644 --- a/ccan/str/test/compile_fail-iscntrl.c +++ b/ccan/str/test/compile_fail-iscntrl.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check iscntrl. diff --git a/ccan/str/test/compile_fail-isdigit.c b/ccan/str/test/compile_fail-isdigit.c index 71d1c714..a3ee439c 100644 --- a/ccan/str/test/compile_fail-isdigit.c +++ b/ccan/str/test/compile_fail-isdigit.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isdigit. diff --git a/ccan/str/test/compile_fail-islower.c b/ccan/str/test/compile_fail-islower.c index ca3f9907..8f5c4561 100644 --- a/ccan/str/test/compile_fail-islower.c +++ b/ccan/str/test/compile_fail-islower.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check islower. diff --git a/ccan/str/test/compile_fail-isprint.c b/ccan/str/test/compile_fail-isprint.c index 6432e41d..85ed028f 100644 --- a/ccan/str/test/compile_fail-isprint.c +++ b/ccan/str/test/compile_fail-isprint.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isprint. diff --git a/ccan/str/test/compile_fail-ispunct.c b/ccan/str/test/compile_fail-ispunct.c index 5d941fcb..09d4279a 100644 --- a/ccan/str/test/compile_fail-ispunct.c +++ b/ccan/str/test/compile_fail-ispunct.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check ispunct. diff --git a/ccan/str/test/compile_fail-isspace.c b/ccan/str/test/compile_fail-isspace.c index bfee1f89..798cfcd4 100644 --- a/ccan/str/test/compile_fail-isspace.c +++ b/ccan/str/test/compile_fail-isspace.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isspace. diff --git a/ccan/str/test/compile_fail-isupper.c b/ccan/str/test/compile_fail-isupper.c index 4cf9fd35..56f5dee1 100644 --- a/ccan/str/test/compile_fail-isupper.c +++ b/ccan/str/test/compile_fail-isupper.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isupper. diff --git a/ccan/str/test/compile_fail-isxdigit.c b/ccan/str/test/compile_fail-isxdigit.c index 65e6006a..ea4d5269 100644 --- a/ccan/str/test/compile_fail-isxdigit.c +++ b/ccan/str/test/compile_fail-isxdigit.c @@ -3,6 +3,7 @@ int main(int argc, char *argv[]) { + (void)argc; #ifdef FAIL #if !HAVE_BUILTIN_TYPES_COMPATIBLE_P || !HAVE_TYPEOF #error We need typeof to check isxdigit. diff --git a/ccan/str/test/compile_fail-strchr.c b/ccan/str/test/compile_fail-strchr.c index 74a7314d..bdaf034a 100644 --- a/ccan/str/test/compile_fail-strchr.c +++ b/ccan/str/test/compile_fail-strchr.c @@ -1,7 +1,7 @@ #define CCAN_STR_DEBUG 1 #include -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL #if !HAVE_TYPEOF diff --git a/ccan/str/test/compile_fail-strrchr.c b/ccan/str/test/compile_fail-strrchr.c index ba7d17e0..57fba0ed 100644 --- a/ccan/str/test/compile_fail-strrchr.c +++ b/ccan/str/test/compile_fail-strrchr.c @@ -1,7 +1,7 @@ #define CCAN_STR_DEBUG 1 #include -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL #if !HAVE_TYPEOF diff --git a/ccan/str/test/compile_fail-strstr.c b/ccan/str/test/compile_fail-strstr.c index deefef65..7bd8ac22 100644 --- a/ccan/str/test/compile_fail-strstr.c +++ b/ccan/str/test/compile_fail-strstr.c @@ -1,7 +1,7 @@ #define CCAN_STR_DEBUG 1 #include -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL #if !HAVE_TYPEOF diff --git a/ccan/str/test/run-STR_MAX_CHARS.c b/ccan/str/test/run-STR_MAX_CHARS.c index ae6969c7..fa45bad8 100644 --- a/ccan/str/test/run-STR_MAX_CHARS.c +++ b/ccan/str/test/run-STR_MAX_CHARS.c @@ -4,7 +4,7 @@ #include #include -int main(int argc, char *argv[]) +int main(void) { char str[1000]; struct { diff --git a/ccan/str/test/run.c b/ccan/str/test/run.c index 0f00ea32..9917fe71 100644 --- a/ccan/str/test/run.c +++ b/ccan/str/test/run.c @@ -21,7 +21,7 @@ static char *strdup_rev(const char *s) return ret; } -int main(int argc, char *argv[]) +int main(void) { unsigned int i, j, n; char *strings[NUM_SUBSTRINGS * NUM_SUBSTRINGS]; diff --git a/ccan/strmap/_info b/ccan/strmap/_info index c128cc27..eba8fe44 100644 --- a/ccan/strmap/_info +++ b/ccan/strmap/_info @@ -16,10 +16,11 @@ * license_depends_compat FAIL * * Example: + * #include * #include * #include * - * static bool dump(const char *member, size_t value, void *unused) + * static bool dump(const char *member, size_t value, void *unused UNNEEDED) * { * printf("%s at %zu. ", member, value); * // true means keep going with iteration. @@ -32,7 +33,7 @@ * STRMAP(size_t) map; * * strmap_init(&map); - * for (i = 1; i < argc; i++) + * for (i = 1; i < (size_t)argc; i++) * // This only adds the first time for this arg. * strmap_add(&map, argv[i], i); * diff --git a/ccan/strmap/test/run-iterate-const.c b/ccan/strmap/test/run-iterate-const.c index 63bea952..dfd9dca7 100644 --- a/ccan/strmap/test/run-iterate-const.c +++ b/ccan/strmap/test/run-iterate-const.c @@ -5,7 +5,7 @@ static bool found = false; /* Make sure const args work. */ -static bool find_string(const char *str, char *member, const char *cmp) +static bool find_string(const char *str UNNEEDED, char *member, const char *cmp) { if (strcmp(member, cmp) == 0) found = true; diff --git a/ccan/strmap/test/run-prefix.c b/ccan/strmap/test/run-prefix.c index d88eb556..6232d71b 100644 --- a/ccan/strmap/test/run-prefix.c +++ b/ccan/strmap/test/run-prefix.c @@ -15,7 +15,7 @@ static bool in_order(const char *index, char *value, unsigned int *count) return true; } -static bool find_empty(const char *index, char *value, char *empty) +static bool find_empty(const char *index, char *value UNNEEDED, char *empty) { if (index == empty) pass("Found empty entry!"); diff --git a/ccan/take/_info b/ccan/take/_info index 69382466..fcb4f318 100644 --- a/ccan/take/_info +++ b/ccan/take/_info @@ -37,7 +37,7 @@ * { * char *b; * - * if (argv[1]) // Mangle in place. + * if (argc > 1) // Mangle in place. * b = base(take(argv[1])); * else * b = base("test/string"); diff --git a/ccan/take/test/run.c b/ccan/take/test/run.c index 0c8ca2a1..ba170fb3 100644 --- a/ccan/take/test/run.c +++ b/ccan/take/test/run.c @@ -15,7 +15,7 @@ static void *my_realloc(void *p, size_t len) #include static int my_allocfail_called; -static void my_allocfail(const void *p) +static void my_allocfail(const void *p UNNEEDED) { my_allocfail_called++; } diff --git a/ccan/tal/_info b/ccan/tal/_info index 890cb2e7..5285c163 100644 --- a/ccan/tal/_info +++ b/ccan/tal/_info @@ -29,7 +29,7 @@ * Example: * #include * #include - * #include + * #include * * // A structure containing a popened command. * struct command { diff --git a/ccan/tal/grab_file/_info b/ccan/tal/grab_file/_info index 68ad089b..056f1099 100644 --- a/ccan/tal/grab_file/_info +++ b/ccan/tal/grab_file/_info @@ -18,6 +18,8 @@ * { * char *file; * + * if (argc > 2) + * err(1, "Takes 0 or 1 arguments"); * file = grab_file(NULL, argv[1]); * if (!file) * err(1, "Could not read file %s", argv[1]); diff --git a/ccan/tal/grab_file/test/run-grab.c b/ccan/tal/grab_file/test/run-grab.c index b258230e..ddb5ca30 100644 --- a/ccan/tal/grab_file/test/run-grab.c +++ b/ccan/tal/grab_file/test/run-grab.c @@ -10,7 +10,7 @@ #include int -main(int argc, char *argv[]) +main(void) { unsigned int i; char **split, *str; diff --git a/ccan/tal/link/_info b/ccan/tal/link/_info index db2ad614..8e39e781 100644 --- a/ccan/tal/link/_info +++ b/ccan/tal/link/_info @@ -87,7 +87,7 @@ * * int main(int argc, char *argv[]) * { - * unsigned int i; + * int i; * const char **values; * * // Initialize cache. diff --git a/ccan/tal/link/link.c b/ccan/tal/link/link.c index c25d97e5..7c8892d2 100644 --- a/ccan/tal/link/link.c +++ b/ccan/tal/link/link.c @@ -15,7 +15,7 @@ struct link { static void linkable_notifier(tal_t *linkable, enum tal_notify_type type, - void *info) + void *info UNNEEDED) { struct linkable *l = tal_parent(linkable); assert(type == TAL_NOTIFY_STEAL || type == TAL_NOTIFY_FREE); diff --git a/ccan/tal/link/test/run.c b/ccan/tal/link/test/run.c index fdbb4f02..e031fef2 100644 --- a/ccan/tal/link/test/run.c +++ b/ccan/tal/link/test/run.c @@ -4,12 +4,12 @@ #include static unsigned int destroy_count = 0; -static void destroy_obj(void *obj) +static void destroy_obj(void *obj UNNEEDED) { destroy_count++; } -int main(int argc, char *argv[]) +int main(void) { char *linkable, *p1, *p2, *p3; void **voidpp; diff --git a/ccan/tal/stack/_info b/ccan/tal/stack/_info index 803a0058..b7de3dd0 100644 --- a/ccan/tal/stack/_info +++ b/ccan/tal/stack/_info @@ -38,7 +38,7 @@ * return retval; * } * - * int main(int argc, char *argv[]) + * int main(void) * { * tal_t *tmp_ctx = tal_newframe(); * int *val = do_work(); diff --git a/ccan/tal/str/_info b/ccan/tal/str/_info index cb81c9e1..3037cfde 100644 --- a/ccan/tal/str/_info +++ b/ccan/tal/str/_info @@ -20,6 +20,8 @@ * char *textfile; * char **lines; * + * if (argc > 2) + * errx(1, "Takes 0 or 1 arguments"); * // Grab lines in file. * textfile = grab_file(NULL, argv[1]); * if (!textfile) diff --git a/ccan/tal/str/str.h b/ccan/tal/str/str.h index 0c182133..5147ca2d 100644 --- a/ccan/tal/str/str.h +++ b/ccan/tal/str/str.h @@ -171,6 +171,7 @@ char *tal_strjoin(const void *ctx, char *strings[], const char *delim, * { * char *person, *input; * + * (void)argc; * // Join args and trim trailing space. * input = tal_strjoin(NULL, argv+1, " ", STR_NO_TRAIL); * if (tal_strreg(NULL, input, diff --git a/ccan/tal/str/test/run-fmt-terminate.c b/ccan/tal/str/test/run-fmt-terminate.c index 9dfd0015..374ca03a 100644 --- a/ccan/tal/str/test/run-fmt-terminate.c +++ b/ccan/tal/str/test/run-fmt-terminate.c @@ -6,7 +6,7 @@ #include "helper.h" /* Empty format string: should still terminate! */ -int main(int argc, char *argv[]) +int main(void) { char *str; const char *fmt = ""; diff --git a/ccan/tal/str/test/run-strndup.c b/ccan/tal/str/test/run-strndup.c index d9673548..55e35fd4 100644 --- a/ccan/tal/str/test/run-strndup.c +++ b/ccan/tal/str/test/run-strndup.c @@ -5,7 +5,7 @@ #include #include "helper.h" -int main(int argc, char *argv[]) +int main(void) { char *str, *copy; diff --git a/ccan/tal/str/test/run-strreg.c b/ccan/tal/str/test/run-strreg.c index fa8a86c6..93b8602a 100644 --- a/ccan/tal/str/test/run-strreg.c +++ b/ccan/tal/str/test/run-strreg.c @@ -14,7 +14,7 @@ static bool find_parent(tal_t *child, tal_t *parent) return false; } -int main(int argc, char *argv[]) +int main(void) { void *ctx = tal_strdup(NULL, "toplevel"); char *a, *b; diff --git a/ccan/tal/str/test/run.c b/ccan/tal/str/test/run.c index 4b9cf1fb..a59d9400 100644 --- a/ccan/tal/str/test/run.c +++ b/ccan/tal/str/test/run.c @@ -10,7 +10,7 @@ static const char *substrings[] = { "far", "bar", "baz", "b", "ba", "z", "ar", NULL }; -int main(int argc, char *argv[]) +int main(void) { char **split, *str; void *ctx; diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 79476772..842059d0 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -323,7 +323,7 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name) } static struct children *add_child_property(struct tal_hdr *parent, - struct tal_hdr *child) + struct tal_hdr *child UNNEEDED) { struct children *prop = allocate(sizeof(*prop)); if (prop) { diff --git a/ccan/tal/test/run-allocfail.c b/ccan/tal/test/run-allocfail.c index a166be3f..97cba9f6 100644 --- a/ccan/tal/test/run-allocfail.c +++ b/ccan/tal/test/run-allocfail.c @@ -30,7 +30,7 @@ static void nofail_on_error(const char *msg) err_count++; } -static void destroy_p(void *p) +static void destroy_p(void *p UNNEEDED) { } diff --git a/ccan/tal/test/run-destructor.c b/ccan/tal/test/run-destructor.c index 87354888..7183f7c5 100644 --- a/ccan/tal/test/run-destructor.c +++ b/ccan/tal/test/run-destructor.c @@ -24,7 +24,7 @@ static void destroy_child(char *p) destroy_count++; } -static void destroy_inc(char *p) +static void destroy_inc(char *p UNNEEDED) { destroy_count++; } diff --git a/ccan/tal/test/run-free.c b/ccan/tal/test/run-free.c index 29aa8c6f..f2126474 100644 --- a/ccan/tal/test/run-free.c +++ b/ccan/tal/test/run-free.c @@ -2,7 +2,7 @@ #include #include -static void destroy_errno(char *p) +static void destroy_errno(char *p UNNEEDED) { errno = ENOENT; } diff --git a/ccan/tal/test/run-notifier.c b/ccan/tal/test/run-notifier.c index b57c902e..3820444f 100644 --- a/ccan/tal/test/run-notifier.c +++ b/ccan/tal/test/run-notifier.c @@ -20,7 +20,7 @@ static void *my_realloc(void *old, size_t size) return new; } -static void notify1(char *p, enum tal_notify_type notify, void *info) +static void notify1(char *p UNNEEDED, enum tal_notify_type notify, void *info) { ok1(ctx == ctx); ok1(notify == expect); @@ -31,7 +31,9 @@ static void notify1(char *p, enum tal_notify_type notify, void *info) notified1++; } -static void notify2(char *ctx, enum tal_notify_type notify, void *info) +static void notify2(char *ctx UNNEEDED, + enum tal_notify_type notify UNNEEDED, + void *info UNNEEDED) { notified2++; } diff --git a/ccan/tal/test/run-overflow.c b/ccan/tal/test/run-overflow.c index d975398b..d1919c1c 100644 --- a/ccan/tal/test/run-overflow.c +++ b/ccan/tal/test/run-overflow.c @@ -4,7 +4,7 @@ static int error_count; -static void my_error(const char *msg) +static void my_error(const char *msg UNNEEDED) { error_count++; } diff --git a/ccan/tal/test/run-test-backend.c b/ccan/tal/test/run-test-backend.c index 8fdfc064..ebcd8111 100644 --- a/ccan/tal/test/run-test-backend.c +++ b/ccan/tal/test/run-test-backend.c @@ -31,7 +31,7 @@ static void *my_realloc(void *old, size_t new_size) #define NUM_ALLOCS 1000 -static void destroy_p(void *p) +static void destroy_p(void *p UNNEEDED) { } diff --git a/ccan/tcon/test/compile_fail-container1.c b/ccan/tcon/test/compile_fail-container1.c index a67e2090..44645a7e 100644 --- a/ccan/tcon/test/compile_fail-container1.c +++ b/ccan/tcon/test/compile_fail-container1.c @@ -22,7 +22,7 @@ struct info_tcon { TCON(TCON_CONTAINER(concan, struct outer, inner)); }; -int main(int argc, char *argv[]) +int main(void) { struct info_tcon info; struct outer ovar; diff --git a/ccan/tcon/test/compile_fail-container1w.c b/ccan/tcon/test/compile_fail-container1w.c index 0226b68e..19ba5bdc 100644 --- a/ccan/tcon/test/compile_fail-container1w.c +++ b/ccan/tcon/test/compile_fail-container1w.c @@ -17,7 +17,7 @@ struct info_base { char *infop; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct info_base, TCON_CONTAINER(concan, struct outer, inner)) info; diff --git a/ccan/tcon/test/compile_fail-container2.c b/ccan/tcon/test/compile_fail-container2.c index 6cad734c..e41984d9 100644 --- a/ccan/tcon/test/compile_fail-container2.c +++ b/ccan/tcon/test/compile_fail-container2.c @@ -22,7 +22,7 @@ struct info_tcon { TCON(TCON_CONTAINER(concan, struct outer, inner)); }; -int main(int argc, char *argv[]) +int main(void) { struct info_tcon info; struct outer ovar; diff --git a/ccan/tcon/test/compile_fail-container2w.c b/ccan/tcon/test/compile_fail-container2w.c index c73123ca..3564ab0c 100644 --- a/ccan/tcon/test/compile_fail-container2w.c +++ b/ccan/tcon/test/compile_fail-container2w.c @@ -17,7 +17,7 @@ struct info_base { char *infop; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct info_base, TCON_CONTAINER(concan, struct outer, inner)) info; diff --git a/ccan/tcon/test/compile_fail-container3.c b/ccan/tcon/test/compile_fail-container3.c index 97473c8c..9185225a 100644 --- a/ccan/tcon/test/compile_fail-container3.c +++ b/ccan/tcon/test/compile_fail-container3.c @@ -22,7 +22,7 @@ struct info_tcon { TCON(TCON_CONTAINER(concan, struct outer, inner)); }; -int main(int argc, char *argv[]) +int main(void) { struct info_tcon info; struct outer ovar; diff --git a/ccan/tcon/test/compile_fail-container3w.c b/ccan/tcon/test/compile_fail-container3w.c index 6930b436..958e5c8b 100644 --- a/ccan/tcon/test/compile_fail-container3w.c +++ b/ccan/tcon/test/compile_fail-container3w.c @@ -17,7 +17,7 @@ struct info_base { char *infop; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct info_base, TCON_CONTAINER(concan, struct outer, inner)) info; diff --git a/ccan/tcon/test/compile_fail-container4.c b/ccan/tcon/test/compile_fail-container4.c index 838ce9b1..b11e8efc 100644 --- a/ccan/tcon/test/compile_fail-container4.c +++ b/ccan/tcon/test/compile_fail-container4.c @@ -22,7 +22,7 @@ struct info_tcon { TCON(TCON_CONTAINER(concan, struct outer, inner)); }; -int main(int argc, char *argv[]) +int main(void) { struct info_tcon info; struct outer ovar; diff --git a/ccan/tcon/test/compile_fail-container4w.c b/ccan/tcon/test/compile_fail-container4w.c index 0d7b367b..d33ce1e5 100644 --- a/ccan/tcon/test/compile_fail-container4w.c +++ b/ccan/tcon/test/compile_fail-container4w.c @@ -17,7 +17,7 @@ struct info_base { char *infop; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct info_base, TCON_CONTAINER(concan, struct outer, inner)) info; diff --git a/ccan/tcon/test/compile_fail-tcon_cast.c b/ccan/tcon/test/compile_fail-tcon_cast.c index 3df0333c..0d83ba3f 100644 --- a/ccan/tcon/test/compile_fail-tcon_cast.c +++ b/ccan/tcon/test/compile_fail-tcon_cast.c @@ -10,7 +10,7 @@ struct int_and_charp_container { TCON(int *tc1; char *tc2); }; -int main(int argc, char *argv[]) +int main(void) { struct int_and_charp_container icon; #ifdef FAIL diff --git a/ccan/tcon/test/compile_fail-tcon_cast_wrap.c b/ccan/tcon/test/compile_fail-tcon_cast_wrap.c index f24cb01b..c9255791 100644 --- a/ccan/tcon/test/compile_fail-tcon_cast_wrap.c +++ b/ccan/tcon/test/compile_fail-tcon_cast_wrap.c @@ -5,7 +5,7 @@ struct container { void *p; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct container, int *tc1; char *tc2) icon; diff --git a/ccan/tcon/test/compile_fail-wrap.c b/ccan/tcon/test/compile_fail-wrap.c index 26da13c3..96010e6c 100644 --- a/ccan/tcon/test/compile_fail-wrap.c +++ b/ccan/tcon/test/compile_fail-wrap.c @@ -5,7 +5,7 @@ struct container { void *p; }; -int main(int argc, char *argv[]) +int main(void) { TCON_WRAP(struct container, int *canary) icon; #ifdef FAIL diff --git a/ccan/tcon/test/compile_fail.c b/ccan/tcon/test/compile_fail.c index 683bbd62..b17d9d2e 100644 --- a/ccan/tcon/test/compile_fail.c +++ b/ccan/tcon/test/compile_fail.c @@ -10,7 +10,7 @@ struct int_container { TCON(int *canary); }; -int main(int argc, char *argv[]) +int main(void) { struct int_container icon; #ifdef FAIL diff --git a/ccan/tcon/test/compile_ok-container.c b/ccan/tcon/test/compile_ok-container.c index a8347f7a..8afacabc 100644 --- a/ccan/tcon/test/compile_ok-container.c +++ b/ccan/tcon/test/compile_ok-container.c @@ -22,7 +22,7 @@ struct info_tcon { TCON(TCON_CONTAINER(fi, struct outer, inner)); }; -int main(int argc, char *argv[]) +int main(void) { /* Const should work! */ const struct outer *ovar = NULL; diff --git a/ccan/tcon/test/compile_ok-sizeof.c b/ccan/tcon/test/compile_ok-sizeof.c index 64ccc136..9c4bf9ac 100644 --- a/ccan/tcon/test/compile_ok-sizeof.c +++ b/ccan/tcon/test/compile_ok-sizeof.c @@ -16,7 +16,7 @@ struct charp_and_int_container { TCON(int tc1; char *tc2); }; -int main(int argc, char *argv[]) +int main(void) { struct int_container icon; struct charp_and_int_container cicon; diff --git a/ccan/tcon/test/compile_ok-value.c b/ccan/tcon/test/compile_ok-value.c index d9c911e6..9620bcbd 100644 --- a/ccan/tcon/test/compile_ok-value.c +++ b/ccan/tcon/test/compile_ok-value.c @@ -26,7 +26,7 @@ struct offs_container { TCON_VALUE(off2, offsetof(struct other_struct, x2))); }; -int main(int argc, char *argv[]) +int main(void) { struct val_container valcon; struct offs_container offscon; diff --git a/ccan/tcon/test/compile_ok-void.c b/ccan/tcon/test/compile_ok-void.c index 694a53b5..442ca659 100644 --- a/ccan/tcon/test/compile_ok-void.c +++ b/ccan/tcon/test/compile_ok-void.c @@ -15,6 +15,7 @@ int main(int argc, char *argv[]) struct void_container vcon; TCON_WRAP(struct container, void *canary) vconw; + (void)argc; tcon_check(&vcon, canary, NULL)->raw.p = NULL; tcon_check(&vcon, canary, argv[0])->raw.p = NULL; tcon_check(&vcon, canary, main)->raw.p = NULL; diff --git a/ccan/tcon/test/compile_ok.c b/ccan/tcon/test/compile_ok.c index f3fe2c6f..6ba5f4c1 100644 --- a/ccan/tcon/test/compile_ok.c +++ b/ccan/tcon/test/compile_ok.c @@ -23,6 +23,7 @@ int main(int argc, char *argv[]) TCON_WRAP(struct container, int tc) iconw; TCON_WRAP(struct container, int tc1; char *tc2) ciconw; + (void)argc; tcon_check(&icon, tc, 7)->raw.p = NULL; tcon_check(&cicon, tc1, 7)->raw.p = argv[0]; tcon_check(&cicon, tc2, argv[0])->raw.p = argv[0]; diff --git a/ccan/tcon/test/run-container.c b/ccan/tcon/test/run-container.c index 88bb2a1c..c08bad5c 100644 --- a/ccan/tcon/test/run-container.c +++ b/ccan/tcon/test/run-container.c @@ -28,7 +28,7 @@ struct info_tcon { TCON_CONTAINER(fi2, struct outer0, inner)); }; -int main(int argc, char *argv[]) +int main(void) { struct info_tcon info; TCON_WRAP(struct info_base, diff --git a/ccan/tcon/test/run-wrap.c b/ccan/tcon/test/run-wrap.c index 0d5cfef6..3493e5ac 100644 --- a/ccan/tcon/test/run-wrap.c +++ b/ccan/tcon/test/run-wrap.c @@ -4,7 +4,7 @@ typedef TCON_WRAP(int, char *canary) canaried_int; -int main(int argc, char *argv[]) +int main(void) { canaried_int ci = TCON_WRAP_INIT(0); diff --git a/ccan/time/test/run-check.c b/ccan/time/test/run-check.c index 3c2e282f..c134afc3 100644 --- a/ccan/time/test/run-check.c +++ b/ccan/time/test/run-check.c @@ -17,10 +17,11 @@ void abort(void) int main(void) { struct timeabs t1, t2, epoch = { { 0, 0 } }; + struct timemono t1m, t2m; struct timerel t3, t4, zero = { { 0, 0 } }; int fds[2]; - plan_tests(64); + plan_tests(69); /* Test time_now */ t1 = time_now(); @@ -43,6 +44,21 @@ int main(void) ok1(timerel_eq(t3, t3)); ok1(!timerel_eq(t3, zero)); + /* Test time_mono */ + t1m = time_mono(); + t2m = time_mono(); + + ok1(!time_less_(t2m.ts, t1m.ts)); + + t3.ts.tv_sec = 1; + t3.ts.tv_nsec = 0; + + ok1(time_less(timemono_between(t2m, t1m), t3)); + ok1(time_less(timemono_since(t1m), t3)); + + ok1(timemono_add(t1m, t3).ts.tv_sec == t1m.ts.tv_sec + 1); + ok1(timemono_add(t2m, t3).ts.tv_nsec == t2m.ts.tv_nsec); + /* Make sure t2 > t1. */ t3.ts.tv_sec = 0; t3.ts.tv_nsec = 1; @@ -156,7 +172,8 @@ int main(void) ok1(t3.ts.tv_sec == 2); ok1(t3.ts.tv_nsec == 147483648); - pipe(fds); + if (pipe(fds) != 0) + exit(1); fflush(stdout); switch (fork()) { diff --git a/ccan/time/test/run-monotonic.c b/ccan/time/test/run-monotonic.c index ed70f3db..2da492d4 100644 --- a/ccan/time/test/run-monotonic.c +++ b/ccan/time/test/run-monotonic.c @@ -7,7 +7,7 @@ int main(void) struct timemono t1, t2; struct timerel t3; - plan_tests(2); + plan_tests(5); /* Test time_mono */ t1 = time_mono(); @@ -18,7 +18,11 @@ int main(void) t3.ts.tv_sec = 1; t3.ts.tv_nsec = 0; - ok1(time_less(timemono_between(t1, t2), t3)); + ok1(time_less(timemono_between(t2, t1), t3)); + ok1(time_less(timemono_since(t1), t3)); + + ok1(timemono_add(t1, t3).ts.tv_sec == t1.ts.tv_sec + 1); + ok1(timemono_add(t2, t3).ts.tv_nsec == t2.ts.tv_nsec); return exit_status(); } diff --git a/ccan/time/time.c b/ccan/time/time.c index d0542f56..27f0d52a 100644 --- a/ccan/time/time.c +++ b/ccan/time/time.c @@ -33,7 +33,7 @@ struct timemono time_mono(void) #else /* Best we can do */ ret.ts = time_now().ts; #endif /* !HAVE_TIME_MONOTONIC */ - return ret; + return TIMEMONO_CHECK(ret); } struct timerel time_divide(struct timerel t, unsigned long div) @@ -128,3 +128,11 @@ struct timeabs timeabs_check(struct timeabs t, const char *abortstr) ret.ts = time_check_(t.ts, abortstr); return ret; } + +struct timemono timemono_check(struct timemono t, const char *abortstr) +{ + struct timemono ret; + + ret.ts = time_check_(t.ts, abortstr); + return ret; +} diff --git a/ccan/time/time.h b/ccan/time/time.h index 5c916f4c..70ebdc9a 100644 --- a/ccan/time/time.h +++ b/ccan/time/time.h @@ -22,10 +22,13 @@ struct timespec { timerel_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ") #define TIMEABS_CHECK(t) \ timeabs_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ") +#define TIMEMONO_CHECK(t) \ + timemono_check((t), __FILE__ ":" stringify(__LINE__) " (" stringify(t) ") ") #else #define TIME_CHECK(t) (t) #define TIMEREL_CHECK(t) (t) #define TIMEABS_CHECK(t) (t) +#define TIMEMONO_CHECK(t) (t) #endif /** @@ -95,7 +98,7 @@ struct timerel timerel_check(struct timerel in, const char *abortstr); /** * timeabs_check - check if an absolute time is malformed. - * @in: the relative time to check (returned) + * @in: the absolute time to check (returned) * @abortstr: the string to print to stderr before aborting (if set). * * This can be used to make sure a time isn't negative and doesn't @@ -113,6 +116,26 @@ struct timerel timerel_check(struct timerel in, const char *abortstr); */ struct timeabs timeabs_check(struct timeabs in, const char *abortstr); +/** + * timemono_check - check if a monotonic time is malformed. + * @in: the monotonic time to check (returned) + * @abortstr: the string to print to stderr before aborting (if set). + * + * This can be used to make sure a time isn't negative and doesn't + * have a tv_nsec >= 1000000000. If it is, and @abortstr is non-NULL, + * that will be printed and abort() is called. Otherwise, if + * @abortstr is NULL then the returned timemono will be normalized and + * tv_sec set to 0 if it was negative. + * + * Note that if ccan/time is compiled with DEBUG, then it will call this + * for all passed and returned times. + * + * Example: + * printf("Now is %lu seconds since mono start\n", + * (long)timemono_check(time_mono(), "time_mono failed?").ts.tv_sec); + */ +struct timemono timemono_check(struct timemono in, const char *abortstr); + /** * time_now - return the current time * @@ -127,7 +150,7 @@ struct timeabs time_now(void); * This value is only really useful for measuring time intervals. * * See also: - * time_since() + * timemono_since() */ struct timemono time_mono(void); @@ -231,6 +254,32 @@ static inline bool timeabs_eq(struct timeabs a, struct timeabs b) && a.ts.tv_nsec == b.ts.tv_nsec; } +/** + * timemono_eq - is a equal to b? + * @a: one monotonic time. + * @b: another monotonic time. + * + * Example: + * #include + * #include + * + * // Can we fork in under a nanosecond? + * static bool fast_fork(void) + * { + * struct timemono start = time_mono(); + * if (fork() != 0) { + * exit(0); + * } + * wait(NULL); + * return timemono_eq(start, time_mono()); + * } + */ +static inline bool timemono_eq(struct timemono a, struct timemono b) +{ + return TIMEMONO_CHECK(a).ts.tv_sec == TIMEMONO_CHECK(b).ts.tv_sec + && a.ts.tv_nsec == b.ts.tv_nsec; +} + /** * timerel_eq - is a equal to b? * @a: one relative time. @@ -320,6 +369,17 @@ static inline struct timerel timemono_between(struct timemono recent, return t; } +/** + * timemono_since - elapsed monotonic time since @old + * @old: a monotonic time from the past. + */ +static inline struct timerel timemono_since(struct timemono old) +{ + struct timemono now = time_mono(); + + return timemono_between(now, TIMEMONO_CHECK(old)); +} + /** * timeabs_sub - subtract a relative time from an absolute time * @abs: the absolute time. @@ -377,6 +437,28 @@ static inline struct timeabs timeabs_add(struct timeabs a, struct timerel b) return t; } +/** + * timemono_add - add a relative to a monotonic time + * @a: the monotonic time. + * @b: a relative time. + * + * The times must not overflow, or the results are undefined. + * + * Example: + * // We do one every second. + * static struct timemono next_timem(void) + * { + * return timemono_add(time_mono(), time_from_msec(1000)); + * } + */ +static inline struct timemono timemono_add(struct timemono a, struct timerel b) +{ + struct timemono t; + + t.ts = time_add_(a.ts, b.ts); + return t; +} + /** * timerel_add - add two relative times * @a: one relative time. diff --git a/ccan/timer/_info b/ccan/timer/_info index 420aba11..9f5ec7a2 100644 --- a/ccan/timer/_info +++ b/ccan/timer/_info @@ -31,21 +31,21 @@ * struct timer *t; * struct timed_string *s; * - * timers_init(&timers, time_now()); + * (void)argc; + * timers_init(&timers, time_mono()); * list_head_init(&strings); * * while (argv[1]) { * s = malloc(sizeof(*s)); * s->string = argv[1]; - * timer_add(&timers, &s->timer, - * timeabs_add(time_now(), - * time_from_msec(atol(argv[2])))); + * timer_addrel(&timers, &s->timer, + * time_from_msec(atol(argv[2]))); * list_add_tail(&strings, &s->node); * argv += 2; * } * * while (!list_empty(&strings)) { - * struct timeabs now = time_now(); + * struct timemono now = time_mono(); * list_for_each(&strings, s, node) * printf("%s", s->string); * while ((t = timers_expire(&timers, now)) != NULL) { diff --git a/ccan/timer/test/run-add.c b/ccan/timer/test/run-add.c index e97bf781..9ad44b7e 100644 --- a/ccan/timer/test/run-add.c +++ b/ccan/timer/test/run-add.c @@ -20,7 +20,7 @@ int main(void) struct timer t; uint64_t diff; unsigned int i; - struct timeabs epoch = { { 0, 0 } }; + struct timemono epoch = { { 0, 0 } }; /* This is how many tests you plan to run */ plan_tests(2 + (18 + (MAX_ORD - 4) * 3) * (18 + (MAX_ORD - 4) * 3)); @@ -38,7 +38,7 @@ int main(void) for (timers.base = 0; timers.base < (1ULL << MAX_ORD)+2; timers.base = next(timers.base)) { - timer_add(&timers, &t, grains_to_time(timers.base + diff)); + timer_addmono(&timers, &t, grains_to_time(timers.base + diff)); ok1(timers_check(&timers, NULL)); timer_del(&timers, &t); } diff --git a/ccan/timer/test/run-corrupt.c b/ccan/timer/test/run-corrupt.c index ee966048..9fd735b9 100644 --- a/ccan/timer/test/run-corrupt.c +++ b/ccan/timer/test/run-corrupt.c @@ -7,25 +7,25 @@ static void new_timer(struct timers *timers, unsigned long nsec) { struct timer *timer; - struct timeabs when; + struct timemono when; timer = malloc(sizeof(*timer)); timer_init(timer); when.ts.tv_sec = 0; when.ts.tv_nsec = nsec; - timer_add(timers, timer, when); + timer_addmono(timers, timer, when); } static void update_and_expire(struct timers *timers) { - struct timeabs when; + struct timemono when; timer_earliest(timers, &when); free(timers_expire(timers, when)); } -int main(int argc, char *argv[]) +int main(void) { - struct timeabs when; + struct timemono when; struct timers timers; plan_tests(7); diff --git a/ccan/timer/test/run-corrupt2.c b/ccan/timer/test/run-corrupt2.c index c2f32976..02e98ff9 100644 --- a/ccan/timer/test/run-corrupt2.c +++ b/ccan/timer/test/run-corrupt2.c @@ -5,9 +5,9 @@ #include /* This is the original pre-cut-down dump. */ -int main(int argc, char *argv[]) +int main(void) { - struct timeabs when; + struct timemono when; struct timers timers; struct timer *timer; @@ -19,1611 +19,1611 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -1631,553 +1631,553 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2185,165 +2185,165 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2351,225 +2351,225 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2577,37 +2577,37 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2615,41 +2615,41 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2659,71 +2659,71 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2731,25 +2731,25 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2761,115 +2761,115 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2877,73 +2877,73 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -2951,49 +2951,49 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3003,35 +3003,35 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3039,19 +3039,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3059,33 +3059,33 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3093,11 +3093,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3105,53 +3105,53 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3159,15 +3159,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3177,15 +3177,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3195,31 +3195,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3227,63 +3227,63 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3293,7 +3293,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3301,79 +3301,79 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3383,7 +3383,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3401,15 +3401,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3423,99 +3423,99 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3523,31 +3523,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3557,15 +3557,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3573,15 +3573,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3591,23 +3591,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3621,27 +3621,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3653,39 +3653,39 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3695,17 +3695,17 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3727,21 +3727,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3755,11 +3755,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3767,23 +3767,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3791,57 +3791,57 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3855,51 +3855,51 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3907,41 +3907,41 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3957,7 +3957,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3965,27 +3965,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -3995,85 +3995,85 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4081,61 +4081,61 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4149,21 +4149,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4175,15 +4175,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4191,31 +4191,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4231,21 +4231,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4255,19 +4255,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4275,15 +4275,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4299,7 +4299,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4307,11 +4307,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4321,49 +4321,49 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4371,69 +4371,69 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 307000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4441,11 +4441,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4453,11 +4453,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4467,7 +4467,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4477,25 +4477,25 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4517,37 +4517,37 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 270000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 237000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4555,7 +4555,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4563,17 +4563,17 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4581,11 +4581,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4595,45 +4595,45 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 117000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4643,33 +4643,33 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 312000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 273000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4677,11 +4677,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4689,19 +4689,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4719,15 +4719,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4735,11 +4735,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 317000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4767,31 +4767,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 291000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4815,33 +4815,33 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4867,19 +4867,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4893,57 +4893,57 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 279000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4967,19 +4967,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 322000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -4995,11 +4995,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5011,37 +5011,37 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 251000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5053,11 +5053,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 276000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5071,7 +5071,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5079,29 +5079,29 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 321000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5125,19 +5125,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5155,31 +5155,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 290000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 236000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5195,15 +5195,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5213,35 +5213,35 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 282000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 318000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5255,31 +5255,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 338000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5291,7 +5291,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 300000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5315,11 +5315,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5329,7 +5329,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5337,19 +5337,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5357,37 +5357,37 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 294000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 297000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5401,25 +5401,25 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 328000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5429,27 +5429,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5459,31 +5459,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 330000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 243000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5493,17 +5493,17 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5525,11 +5525,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5541,15 +5541,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5565,7 +5565,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 315000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5609,27 +5609,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 284000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5639,23 +5639,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 323000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 306000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 320000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 269000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5673,27 +5673,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 351000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5703,43 +5703,43 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 342000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 319000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5749,11 +5749,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 332000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5769,19 +5769,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 340000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 302000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 278000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5789,15 +5789,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 324000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5807,19 +5807,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5867,15 +5867,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5883,73 +5883,73 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 298000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 360000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 349000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 261000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 289000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5959,29 +5959,29 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 281000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 327000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 309000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 353000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -5997,23 +5997,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 347000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 326000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 254000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6021,7 +6021,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 246000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6031,17 +6031,17 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 308000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6065,19 +6065,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 293000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 304000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6107,33 +6107,33 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 334000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 314000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 368000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 335000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6141,7 +6141,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 272000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); free(timers_expire(&timers, when)); timers_check(&timers, "expire"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); @@ -6153,23 +6153,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 260000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 305000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); when.ts.tv_sec = 0; when.ts.tv_nsec = 263000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); timers_check(&timers, "add"); + timer_addmono(&timers, timer, when); timers_check(&timers, "add"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); timer_earliest(&timers, &when); timers_check(&timers, "earliest"); diff --git a/ccan/timer/test/run-expiry.c b/ccan/timer/test/run-expiry.c index 1c276c2c..39b5b5ea 100644 --- a/ccan/timer/test/run-expiry.c +++ b/ccan/timer/test/run-expiry.c @@ -14,7 +14,7 @@ int main(void) timers_init(&timers, grains_to_time(1364984760903400ULL)); ok1(timers.base == 1364984760903400ULL); timer_init(&t); - timer_add(&timers, &t, grains_to_time(1364984761003398ULL)); + timer_addmono(&timers, &t, grains_to_time(1364984761003398ULL)); ok1(t.time == 1364984761003398ULL); ok1(timers.first == 1364984761003398ULL); ok1(!timers_expire(&timers, grains_to_time(1364984760903444ULL))); diff --git a/ccan/timer/test/run-ff.c b/ccan/timer/test/run-ff.c index 49c6e374..37f035da 100644 --- a/ccan/timer/test/run-ff.c +++ b/ccan/timer/test/run-ff.c @@ -3,10 +3,10 @@ #include #include -static struct timeabs timeabs_from_usec(unsigned long long usec) +static struct timemono timemono_from_usec(unsigned long long usec) { - struct timeabs epoch = { { 0, 0 } }; - return timeabs_add(epoch, time_from_usec(usec)); + struct timemono epoch = { { 0, 0 } }; + return timemono_add(epoch, time_from_usec(usec)); } int main(void) @@ -17,13 +17,13 @@ int main(void) /* This is how many tests you plan to run */ plan_tests(3); - timers_init(&timers, timeabs_from_usec(1364726722653919ULL)); + timers_init(&timers, timemono_from_usec(1364726722653919ULL)); timer_init(&t); - timer_add(&timers, &t, timeabs_from_usec(1364726722703919ULL)); - ok1(!timers_expire(&timers, timeabs_from_usec(1364726722653920ULL))); - expired = timers_expire(&timers, timeabs_from_usec(1364726725454187ULL)); + timer_addmono(&timers, &t, timemono_from_usec(1364726722703919ULL)); + ok1(!timers_expire(&timers, timemono_from_usec(1364726722653920ULL))); + expired = timers_expire(&timers, timemono_from_usec(1364726725454187ULL)); ok1(expired == &t); - ok1(!timers_expire(&timers, timeabs_from_usec(1364726725454187ULL))); + ok1(!timers_expire(&timers, timemono_from_usec(1364726725454187ULL))); timers_cleanup(&timers); /* This exits depending on whether all tests passed */ diff --git a/ccan/timer/test/run-original-corrupt.c b/ccan/timer/test/run-original-corrupt.c index 8bd2b428..8a447c84 100644 --- a/ccan/timer/test/run-original-corrupt.c +++ b/ccan/timer/test/run-original-corrupt.c @@ -5,9 +5,9 @@ #include /* This is the original pre-cut-down dump. */ -int main(int argc, char *argv[]) +int main(void) { - struct timeabs when; + struct timemono when; struct timers timers; struct timer *timer; @@ -19,1611 +19,1611 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 18000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 158000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 13000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 39000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 33000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 90000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 20000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 179000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 161000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 64000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 12000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 149000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 31000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 22000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 17000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 67000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 54000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 32000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 84000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 24000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 187000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 163000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 28000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 27000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 71000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 61000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 15000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 16000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 36000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 46000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 21000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 37000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 73000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 40000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 124000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 45000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 14000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 72000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 58000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -1631,553 +1631,553 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 43000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 188000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 42000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 30000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 133000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 201000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 41000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 25000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 204000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 79000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 94000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 50000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 44000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 35000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 152000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 65000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 47000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 38000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 156000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 140000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 49000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 57000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 129000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 76000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2185,165 +2185,165 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 56000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 59000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 63000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 53000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 75000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 151000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 52000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 218000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2351,225 +2351,225 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 176000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 211000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 62000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 86000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 51000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 200000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 125000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 93000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 48000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 60000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 175000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 88000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 234000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2577,37 +2577,37 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 191000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2615,41 +2615,41 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 66000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 157000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2659,71 +2659,71 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 142000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 80000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 123000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 239000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 108000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 242000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2731,25 +2731,25 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 164000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2761,115 +2761,115 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 68000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 92000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 105000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 70000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2877,73 +2877,73 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 170000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 182000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 209000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 78000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 247000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -2951,49 +2951,49 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 206000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 153000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 171000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 91000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3003,35 +3003,35 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 82000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 145000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3039,19 +3039,19 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3059,33 +3059,33 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 221000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3093,11 +3093,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 136000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3105,53 +3105,53 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 238000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 81000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3159,15 +3159,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 205000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3177,15 +3177,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 138000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3195,31 +3195,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 132000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 77000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 258000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3227,63 +3227,63 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 69000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 241000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 74000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 185000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 83000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 240000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3293,7 +3293,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3301,79 +3301,79 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 194000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 266000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 87000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 195000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 262000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 217000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 228000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 167000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3383,7 +3383,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 229000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3401,15 +3401,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 97000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 192000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3423,99 +3423,99 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 116000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 85000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 155000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 202000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 265000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 216000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 184000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 107000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 89000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 115000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3523,31 +3523,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 147000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 98000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 106000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 148000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 257000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3557,15 +3557,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 173000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 177000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 102000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3573,15 +3573,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 166000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3591,23 +3591,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 189000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 252000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3621,27 +3621,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 110000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 113000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 159000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 174000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3653,39 +3653,39 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 130000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 232000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 224000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 168000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3695,17 +3695,17 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 197000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 231000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3727,21 +3727,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 274000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 169000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 99000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 122000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3755,11 +3755,11 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 223000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3767,23 +3767,23 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 213000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 178000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 264000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 134000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 210000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3791,57 +3791,57 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 245000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 135000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 215000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 230000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 150000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 154000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 109000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 244000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 203000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 160000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 196000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 95000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3855,51 +3855,51 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 226000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 292000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 112000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 128000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 162000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 143000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 180000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3907,41 +3907,41 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 96000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 131000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 256000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 183000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 104000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 100000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3957,7 +3957,7 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3965,27 +3965,27 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 127000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 101000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 114000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 190000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 119000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -3995,85 +3995,85 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 220000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 103000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 141000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 227000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 277000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 146000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 144000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 198000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 250000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 288000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 286000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 253000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -4081,61 +4081,61 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 249000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 137000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 207000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 208000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 193000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 118000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 165000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 222000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 121000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 181000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 267000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 295000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 255000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -4149,21 +4149,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 225000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 139000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 235000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 186000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -4175,15 +4175,15 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 219000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 214000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 233000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -4191,31 +4191,31 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 120000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 212000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 268000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 259000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 111000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 172000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 248000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); timer_earliest(&timers, &when); @@ -4231,21 +4231,21 @@ int main(int argc, char *argv[]) when.ts.tv_sec = 0; when.ts.tv_nsec = 299000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); when.ts.tv_sec = 0; when.ts.tv_nsec = 126000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 275000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); when.ts.tv_sec = 0; when.ts.tv_nsec = 199000000; timer = malloc(sizeof(*timer)); timer_init(timer); - timer_add(&timers, timer, when); + timer_addmono(&timers, timer, when); ok1(timers_check(&timers, NULL)); timer_earliest(&timers, &when); free(timers_expire(&timers, when)); diff --git a/ccan/timer/test/run.c b/ccan/timer/test/run.c index e2d467eb..ca0435e3 100644 --- a/ccan/timer/test/run.c +++ b/ccan/timer/test/run.c @@ -1,25 +1,31 @@ #define CCAN_TIMER_DEBUG #include +#include + +#define time_mono() fake_mono_time + +static struct timemono fake_mono_time; + /* Include the C files directly. */ #include #include -static struct timeabs timeabs_from_nsec(unsigned long long nsec) +static struct timemono timemono_from_nsec(unsigned long long nsec) { - struct timeabs epoch = { { 0, 0 } }; - return timeabs_add(epoch, time_from_nsec(nsec)); + struct timemono epoch = { { 0, 0 } }; + return timemono_add(epoch, time_from_nsec(nsec)); } int main(void) { struct timers timers; struct timer t[64]; - struct timeabs earliest; + struct timemono earliest; uint64_t i; - struct timeabs epoch = { { 0, 0 } }; + const struct timemono epoch = { { 0, 0 } }; /* This is how many tests you plan to run */ - plan_tests(488); + plan_tests(495); timers_init(&timers, epoch); ok1(timers_check(&timers, NULL)); @@ -29,10 +35,10 @@ int main(void) /* timer_del can be called immediately after init. */ timer_del(&timers, &t[0]); - timer_add(&timers, &t[0], timeabs_from_nsec(1)); + timer_addmono(&timers, &t[0], timemono_from_nsec(1)); ok1(timers_check(&timers, NULL)); ok1(timer_earliest(&timers, &earliest)); - ok1(timeabs_eq(earliest, grains_to_time(t[0].time))); + ok1(timemono_eq(earliest, grains_to_time(t[0].time))); timer_del(&timers, &t[0]); ok1(timers_check(&timers, NULL)); ok1(!timer_earliest(&timers, &earliest)); @@ -43,10 +49,10 @@ int main(void) /* Check timer ordering. */ for (i = 0; i < 32; i++) { timer_init(&t[i*2]); - timer_add(&timers, &t[i*2], timeabs_from_nsec(1ULL << i)); + timer_addmono(&timers, &t[i*2], timemono_from_nsec(1ULL << i)); ok1(timers_check(&timers, NULL)); timer_init(&t[i*2+1]); - timer_add(&timers, &t[i*2+1], timeabs_from_nsec((1ULL << i) + 1)); + timer_addmono(&timers, &t[i*2+1], timemono_from_nsec((1ULL << i) + 1)); ok1(timers_check(&timers, NULL)); } @@ -68,9 +74,9 @@ int main(void) for (i = 0; i < 32; i++) { uint64_t exp = (uint64_t)TIMER_GRANULARITY << i; - timer_add(&timers, &t[i*2], timeabs_from_nsec(exp)); + timer_addmono(&timers, &t[i*2], timemono_from_nsec(exp)); ok1(timers_check(&timers, NULL)); - timer_add(&timers, &t[i*2+1], timeabs_from_nsec(exp + 1)); + timer_addmono(&timers, &t[i*2+1], timemono_from_nsec(exp + 1)); ok1(timers_check(&timers, NULL)); } @@ -90,7 +96,19 @@ int main(void) } ok1(!timer_earliest(&timers, &earliest)); - + ok1(timers_check(&timers, NULL)); + timers_cleanup(&timers); + + /* Relative timers. */ + timers_init(&timers, epoch); + fake_mono_time = timemono_from_nsec(TIMER_GRANULARITY); + timer_addrel(&timers, &t[0], time_from_sec(1)); + ok1(timer_earliest(&timers, &earliest)); + ok1(timers_check(&timers, NULL)); + ok1(earliest.ts.tv_sec == 1 && earliest.ts.tv_nsec == TIMER_GRANULARITY); + ok1(timers_expire(&timers, earliest) == &t[0]); + ok1(!timer_earliest(&timers, &earliest)); + ok1(timers_check(&timers, NULL)); timers_cleanup(&timers); /* This exits depending on whether all tests passed */ diff --git a/ccan/timer/timer.c b/ccan/timer/timer.c index 8d220a6a..91f46393 100644 --- a/ccan/timer/timer.c +++ b/ccan/timer/timer.c @@ -12,15 +12,15 @@ struct timer_level { struct list_head list[PER_LEVEL]; }; -static uint64_t time_to_grains(struct timeabs t) +static uint64_t time_to_grains(struct timemono t) { return t.ts.tv_sec * ((uint64_t)1000000000 / TIMER_GRANULARITY) + (t.ts.tv_nsec / TIMER_GRANULARITY); } -static struct timeabs grains_to_time(uint64_t grains) +static struct timemono grains_to_time(uint64_t grains) { - struct timeabs t; + struct timemono t; t.ts.tv_sec = grains / (1000000000 / TIMER_GRANULARITY); t.ts.tv_nsec = (grains % (1000000000 / TIMER_GRANULARITY)) @@ -28,7 +28,7 @@ static struct timeabs grains_to_time(uint64_t grains) return t; } -void timers_init(struct timers *timers, struct timeabs start) +void timers_init(struct timers *timers, struct timemono start) { unsigned int i; @@ -79,7 +79,26 @@ static bool list_node_initted(const struct list_node *n) return n->prev == n; } -void timer_add(struct timers *timers, struct timer *t, struct timeabs when) +void timer_addrel(struct timers *timers, struct timer *t, struct timerel rel) +{ + assert(list_node_initted(&t->list)); + + t->time = time_to_grains(timemono_add(time_mono(), rel)); + +#if TIME_HAVE_MONOTONIC + assert(t->time >= timers->base); +#else + /* Added in the past? Treat it as imminent. */ + if (t->time < timers->base) + t->time = timers->base; +#endif + if (t->time < timers->first) + timers->first = t->time; + + timer_add_raw(timers, t); +} + +void timer_addmono(struct timers *timers, struct timer *t, struct timemono when) { assert(list_node_initted(&t->list)); @@ -95,7 +114,7 @@ void timer_add(struct timers *timers, struct timer *t, struct timeabs when) } /* FIXME: inline */ -void timer_del(struct timers *timers, struct timer *t) +void timer_del(struct timers *timers UNNEEDED, struct timer *t) { list_del_init(&t->list); } @@ -241,7 +260,7 @@ static bool update_first(struct timers *timers) return true; } -bool timer_earliest(struct timers *timers, struct timeabs *first) +bool timer_earliest(struct timers *timers, struct timemono *first) { if (!update_first(timers)) return false; @@ -298,7 +317,7 @@ static void timer_fast_forward(struct timers *timers, uint64_t time) } /* Returns an expired timer. */ -struct timer *timers_expire(struct timers *timers, struct timeabs expire) +struct timer *timers_expire(struct timers *timers, struct timemono expire) { uint64_t now = time_to_grains(expire); unsigned int off; diff --git a/ccan/timer/timer.h b/ccan/timer/timer.h index e678f7f7..5c40a3bb 100644 --- a/ccan/timer/timer.h +++ b/ccan/timer/timer.h @@ -29,9 +29,9 @@ struct timer; * Example: * struct timers timeouts; * - * timers_init(&timeouts, time_now()); + * timers_init(&timeouts, time_mono()); */ -void timers_init(struct timers *timers, struct timeabs start); +void timers_init(struct timers *timers, struct timemono start); /** * timers_cleanup - free allocations within timers struct. @@ -56,19 +56,39 @@ void timers_cleanup(struct timers *timers); void timer_init(struct timer *t); /** - * timer_add - insert a timer. + * timer_addrel - insert a relative timer. * @timers: the struct timers * @timer: the (initialized or timer_del'd) timer to add - * @when: when @timer expires. + * @rel: when @timer expires (relative). + * + * This efficiently adds @timer to @timers, to expire @rel (rounded to + * TIMER_GRANULARITY nanoseconds) after the current time. This + * is a convenient wrapper around timer_addmono(). + * + * Example: + * // Timeout in 100ms. + * timer_addrel(&timeouts, &t, time_from_msec(100)); + */ +void timer_addrel(struct timers *timers, struct timer *timer, struct timerel rel); + +/** + * timer_addmono - insert an absolute timer. + * @timers: the struct timers + * @timer: the (initialized or timer_del'd) timer to add + * @when: when @timer expires (absolute). * * This efficiently adds @timer to @timers, to expire @when (rounded to * TIMER_GRANULARITY nanoseconds). * + * Note that if @when is before time_mono(), then it will be set to expire + * immediately. + * * Example: * // Timeout in 100ms. - * timer_add(&timeouts, &t, timeabs_add(time_now(), time_from_msec(100))); + * timer_addmono(&timeouts, &t, timemono_add(time_mono(), time_from_msec(100))); */ -void timer_add(struct timers *timers, struct timer *timer, struct timeabs when); +void timer_addmono(struct timers *timers, struct timer *timer, + struct timemono when); /** * timer_del - remove a timer. @@ -94,10 +114,10 @@ void timer_del(struct timers *timers, struct timer *timer); * timer (rounded to TIMER_GRANULARITY nanoseconds), and returns true. * * Example: - * struct timeabs next = { { (time_t)-1ULL, -1UL } }; + * struct timemono next = { { (time_t)-1ULL, -1UL } }; * timer_earliest(&timeouts, &next); */ -bool timer_earliest(struct timers *timers, struct timeabs *first); +bool timer_earliest(struct timers *timers, struct timemono *first); /** * timers_expire - update timers structure and remove one expire timer. @@ -118,11 +138,11 @@ bool timer_earliest(struct timers *timers, struct timeabs *first); * Example: * struct timer *expired; * - * while ((expired = timers_expire(&timeouts, time_now())) != NULL) + * while ((expired = timers_expire(&timeouts, time_mono())) != NULL) * printf("Timer expired!\n"); * */ -struct timer *timers_expire(struct timers *timers, struct timeabs expire); +struct timer *timers_expire(struct timers *timers, struct timemono expire); /** * timers_check - check timer structure for consistency diff --git a/ccan/typesafe_cb/_info b/ccan/typesafe_cb/_info index 165852a3..b4f379dd 100644 --- a/ccan/typesafe_cb/_info +++ b/ccan/typesafe_cb/_info @@ -106,7 +106,7 @@ * // Silly game to find the longest chain of values. * int main(int argc, char *argv[]) * { - * int i, run = 1, num = argv[1] ? atoi(argv[1]) : 0; + * int i, run = 1, num = argc > 1 ? atoi(argv[1]) : 0; * * for (i = 1; i < 1024;) { * // Since run is an int, compiler checks "add" does too. diff --git a/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c b/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c index 11d42f4c..746facae 100644 --- a/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c +++ b/ccan/typesafe_cb/test/compile_fail-cast_if_type-promotable.c @@ -3,12 +3,13 @@ static void _set_some_value(void *val) { + (void)val; } #define set_some_value(expr) \ _set_some_value(typesafe_cb_cast(void *, long, (expr))) -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL bool x = 0; diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c index c4033364..c9d47c50 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb-int.c @@ -15,9 +15,10 @@ void _callback(void (*fn)(void *arg), void *arg) void my_callback(int something); void my_callback(int something) { + (void)something; } -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL /* This fails due to arg, not due to cast. */ diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c index 81e36d7b..5717f97b 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb.c @@ -3,6 +3,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ @@ -10,9 +12,10 @@ static void _register_callback(void (*cb)(void *arg), void *arg) static void my_callback(char *p) { + (void)p; } -int main(int argc, char *argv[]) +int main(void) { char str[] = "hello world"; #ifdef FAIL diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c index 62b5f91e..d85886c9 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast-multi.c @@ -23,9 +23,10 @@ struct other { static void take_any(struct any *any) { + (void)any; } -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL struct other diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c index d2e6f2ab..7fa596cf 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_cast.c @@ -4,12 +4,13 @@ void _set_some_value(void *val); void _set_some_value(void *val) { + (void)val; } #define set_some_value(expr) \ _set_some_value(typesafe_cb_cast(void *, unsigned long, (expr))) -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL int x = 0; diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c index 7d353085..2100368f 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_postargs.c @@ -3,15 +3,19 @@ static void _register_callback(void (*cb)(void *arg, int x), void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ _register_callback(typesafe_cb_postargs(void, void *, (cb), (arg), int), (arg)) static void my_callback(char *p, int x) { + (void)p; + (void)x; } -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL int *p; diff --git a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c index bd55c672..d359a77f 100644 --- a/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c +++ b/ccan/typesafe_cb/test/compile_fail-typesafe_cb_preargs.c @@ -3,6 +3,8 @@ static void _register_callback(void (*cb)(int x, void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ @@ -10,9 +12,11 @@ static void _register_callback(void (*cb)(int x, void *arg), void *arg) static void my_callback(int x, char *p) { + (void)p; + (void)x; } -int main(int argc, char *argv[]) +int main(void) { #ifdef FAIL int *p; diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c index 265de8b1..738ec96b 100644 --- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c +++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-NULL.c @@ -5,12 +5,14 @@ static void _register_callback(void (*cb)(const void *arg), const void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ _register_callback(typesafe_cb(void, const void *, (cb), (arg)), (arg)) -int main(int argc, char *argv[]) +int main(void) { register_callback(NULL, "hello world"); return 0; diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c index aa50bad6..bb71042c 100644 --- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c +++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-undefined.c @@ -5,6 +5,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ @@ -12,6 +14,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg) static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback_pre(cb, arg) \ @@ -19,6 +23,8 @@ static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg) static void _register_callback_post(void (*cb)(void *arg, int x), void *arg) { + (void)cb; + (void)arg; } #define register_callback_post(cb, arg) \ @@ -28,17 +34,22 @@ struct undefined; static void my_callback(struct undefined *undef) { + (void)undef; } static void my_callback_pre(int x, struct undefined *undef) { + (void)x; + (void)undef; } static void my_callback_post(struct undefined *undef, int x) { + (void)undef; + (void)x; } -int main(int argc, char *argv[]) +int main(void) { struct undefined *handle = NULL; diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c index f6a2bfec..1cb1057d 100644 --- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c +++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb-vars.c @@ -5,6 +5,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback(cb, arg) \ @@ -12,6 +14,8 @@ static void _register_callback(void (*cb)(void *arg), void *arg) static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg) { + (void)cb; + (void)arg; } #define register_callback_pre(cb, arg) \ @@ -19,6 +23,8 @@ static void _register_callback_pre(void (*cb)(int x, void *arg), void *arg) static void _register_callback_post(void (*cb)(void *arg, int x), void *arg) { + (void)cb; + (void)arg; } #define register_callback_post(cb, arg) \ @@ -28,17 +34,22 @@ struct undefined; static void my_callback(struct undefined *undef) { + (void)undef; } static void my_callback_pre(int x, struct undefined *undef) { + (void)x; + (void)undef; } static void my_callback_post(struct undefined *undef, int x) { + (void)x; + (void)undef; } -int main(int argc, char *argv[]) +int main(void) { struct undefined *handle = NULL; void (*cb)(struct undefined *undef) = my_callback; diff --git a/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c b/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c index 4bb3b8bf..bd7b7d65 100644 --- a/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c +++ b/ccan/typesafe_cb/test/compile_ok-typesafe_cb_cast.c @@ -19,9 +19,10 @@ struct any { static void take_any(struct any *any) { + (void)any; } -int main(int argc, char *argv[]) +int main(void) { /* Otherwise we get unused warnings for these. */ struct foo *foo = NULL; diff --git a/ccan/typesafe_cb/test/run.c b/ccan/typesafe_cb/test/run.c index 79863db8..bebea400 100644 --- a/ccan/typesafe_cb/test/run.c +++ b/ccan/typesafe_cb/test/run.c @@ -89,7 +89,7 @@ struct callback_postargs cb_postargs = { typesafe_cb_postargs(void, void *, my_callback_postargs, (char *)(intptr_t)"hi", int, int), "hi" }; -int main(int argc, char *argv[]) +int main(void) { void *p = &dummy; unsigned long l = (unsigned long)p; diff --git a/ccan/wwviaudio/_info b/ccan/wwviaudio/_info index 5fb6beb9..501ad3d9 100644 --- a/ccan/wwviaudio/_info +++ b/ccan/wwviaudio/_info @@ -37,8 +37,8 @@ * wwviaudio_cancel_all_sounds(); * wwviaduio_stop_portaudio(); * + * Ccanlint: examples_compile FAIL * License: GPL (v2 or any later version) - * */ int main(int argc, char *argv[]) { diff --git a/ccan/wwviaudio/wwviaudio.c b/ccan/wwviaudio/wwviaudio.c index 5870411a..d6fabfbd 100644 --- a/ccan/wwviaudio/wwviaudio.c +++ b/ccan/wwviaudio/wwviaudio.c @@ -29,6 +29,7 @@ #include #include #include +#include #define WWVIAUDIO_DEFINE_GLOBALS #include "wwviaudio.h" @@ -147,8 +148,8 @@ int wwviaudio_read_ogg_clip(int clipnum, char *filename) rc = ogg_to_pcm(filebuf, &clip[clipnum].sample, &samplesize, &sample_rate, &nchannels, &nframes); if (clip[clipnum].sample == NULL) { - printf("Can't get memory for sound data for %llu frames in %s\n", - nframes, filebuf); + printf("Can't get memory for sound data for %"PRIu64 + " frames in %s\n", nframes, filebuf); goto error; } diff --git a/tools/ccanlint/async.c b/tools/ccanlint/async.c index d867079d..e5b9078d 100644 --- a/tools/ccanlint/async.c +++ b/tools/ccanlint/async.c @@ -34,7 +34,7 @@ struct command { const void *ctx; }; -static void killme(int sig) +static void killme(int sig UNNEEDED) { kill(-getpid(), SIGKILL); } diff --git a/tools/ccanlint/ccanlint.c b/tools/ccanlint/ccanlint.c index e2a687e0..0ed969cb 100644 --- a/tools/ccanlint/ccanlint.c +++ b/tools/ccanlint/ccanlint.c @@ -84,12 +84,12 @@ static bool skip_test(struct dgraph_node *node, const char *why) return true; } -static const char *dep_failed(struct manifest *m) +static const char *dep_failed(struct manifest *m UNNEEDED) { return "dependency couldn't run"; } -static bool cannot_run(struct dgraph_node *node, void *all) +static bool cannot_run(struct dgraph_node *node, void *all UNNEEDED) { struct ccanlint *c = container_of(node, struct ccanlint, node); c->can_run = dep_failed; @@ -98,7 +98,7 @@ static bool cannot_run(struct dgraph_node *node, void *all) } struct run_info { - bool quiet; + bool noninteractive; unsigned int score, total; struct manifest *m; const char *prefix; @@ -165,7 +165,7 @@ static bool run_test(struct dgraph_node *n, struct run_info *run) } assert(score->score <= score->total); - if ((!score->pass && !run->quiet) + if (!score->pass || (score->score < score->total && verbose) || verbose > 1) { printf("%s%s (%s): %s", @@ -176,13 +176,13 @@ static bool run_test(struct dgraph_node *n, struct run_info *run) printf("\n"); } - if ((!run->quiet && !score->pass) || verbose) { + if (!score->pass || verbose) { if (score->error) { printf("%s%s", score->error, strends(score->error, "\n") ? "" : "\n"); } } - if (!run->quiet && score->score < score->total && i->handle) + if (!run->noninteractive && score->score < score->total && i->handle) i->handle(run->m, score); if (!score->pass) { @@ -215,7 +215,7 @@ static void register_test(struct ccanlint *test) dgraph_init_node(&test->node); } -static bool get_test(const char *member, struct ccanlint *i, +static bool get_test(const char *member UNNEEDED, struct ccanlint *i, struct ccanlint **ret) { if (tlist_empty(&i->node.edge[DGRAPH_TO])) { @@ -252,7 +252,8 @@ bool is_excluded(const char *name) return find_test(name)->skip != NULL; } -static bool init_deps(const char *member, struct ccanlint *c, void *unused) +static bool init_deps(const char *member UNNEEDED, + struct ccanlint *c, void *unused UNNEEDED) { char **deps = tal_strsplit(NULL, c->needs, " ", STR_EMPTY_OK); unsigned int i; @@ -270,7 +271,7 @@ static bool init_deps(const char *member, struct ccanlint *c, void *unused) return true; } -static bool check_names(const char *member, struct ccanlint *c, +static bool check_names(const char *member UNNEEDED, struct ccanlint *c, ccanlint_map_t *names) { if (!strmap_add(names, c->name, c)) @@ -299,7 +300,7 @@ static void init_tests(void) strmap_clear(&names); } -static bool reset_test(struct dgraph_node *node, void *unused) +static bool reset_test(struct dgraph_node *node, void *unused UNNEEDED) { struct ccanlint *c = container_of(node, struct ccanlint, node); c->skip = NULL; @@ -312,7 +313,8 @@ static void reset_tests(struct dgraph_node *all) dgraph_traverse_to(all, reset_test, NULL); } -static bool print_deps(const char *member, struct ccanlint *c, void *unused) +static bool print_deps(const char *member UNNEEDED, + struct ccanlint *c, void *unused UNNEEDED) { if (!tlist_empty(&c->node.edge[DGRAPH_FROM])) { struct dgraph_edge *e; @@ -341,7 +343,7 @@ static void show_tmpdir(const char *dir) printf("You can find ccanlint working files in '%s'\n", dir); } -static char *keep_tests(void *unused) +static char *keep_tests(void *unused UNNEEDED) { keep_results = true; @@ -359,7 +361,7 @@ static bool remove_test(struct dgraph_node *node, const char *why) return true; } -static char *exclude_test(const char *testname, void *unused) +static char *exclude_test(const char *testname, void *unused UNNEEDED) { struct ccanlint *i = find_test(testname); if (!i) @@ -378,7 +380,7 @@ static void skip_test_and_deps(struct ccanlint *c, const char *why) skip_test(&c->node, why); } -static char *list_tests(void *arg) +static char *list_tests(void *arg UNNEEDED) { struct ccanlint *i; @@ -392,7 +394,8 @@ static char *list_tests(void *arg) exit(0); } -static bool draw_test(const char *member, struct ccanlint *c, const char *style) +static bool draw_test(const char *member UNNEEDED, + struct ccanlint *c, const char *style) { /* * todo: escape labels in case ccanlint test keys have @@ -407,7 +410,8 @@ static void test_dgraph_vertices(const char *style) strmap_iterate(&tests, draw_test, style); } -static bool draw_edges(const char *member, struct ccanlint *c, void *unused) +static bool draw_edges(const char *member UNNEEDED, + struct ccanlint *c, void *unused UNNEEDED) { struct dgraph_edge *e; @@ -425,7 +429,7 @@ static void test_dgraph_edges(void) strmap_iterate(&tests, draw_edges, NULL); } -static char *test_dependency_graph(void *arg) +static char *test_dependency_graph(void *arg UNNEEDED) { puts("digraph G {"); @@ -563,7 +567,7 @@ static bool run_tests(struct dgraph_node *all, struct run_info run; const char *comment = ""; - run.quiet = summary; + run.noninteractive = summary; run.m = m; run.prefix = prefix; run.score = run.total = 0; @@ -586,7 +590,7 @@ static bool run_tests(struct dgraph_node *all, return run.pass; } -static bool add_to_all(const char *member, struct ccanlint *c, +static bool add_to_all(const char *member UNNEEDED, struct ccanlint *c, struct dgraph_node *all) { /* If we're excluded on cmdline, don't add. */ @@ -614,7 +618,7 @@ static bool test_module(struct dgraph_node *all, int main(int argc, char *argv[]) { bool summary = false, pass = true, deps_fail_ignore = false; - unsigned int i; + int i; const char *prefix = ""; char *cwd = path_cwd(NULL), *dir; struct ccanlint top; /* cannot_run may try to set ->can_run */ @@ -634,7 +638,7 @@ int main(int argc, char *argv[]) opt_register_noarg("-k|--keep", keep_tests, NULL, "do not delete ccanlint working files"); opt_register_noarg("--summary|-s", opt_set_bool, &summary, - "simply give one line summary"); + "give results only, no interactive correction"); opt_register_arg("-x|--exclude ", exclude_test, NULL, NULL, "exclude (can be used multiple times)"); opt_register_arg("--timeout ", opt_set_uintval, diff --git a/tools/ccanlint/file_analysis.c b/tools/ccanlint/file_analysis.c index abcf0795..d2fe2a4c 100644 --- a/tools/ccanlint/file_analysis.c +++ b/tools/ccanlint/file_analysis.c @@ -417,7 +417,7 @@ void score_file_error(struct score *score, struct ccan_file *f, unsigned line, } -char *get_or_compile_info(const void *ctx, const char *dir) +char *get_or_compile_info(const void *ctx UNNEEDED, const char *dir) { struct manifest *m = get_manifest(NULL, dir); diff --git a/tools/ccanlint/tests/avoids_cpp_reserved.c b/tools/ccanlint/tests/avoids_cpp_reserved.c index 78ba6ca8..8e496180 100644 --- a/tools/ccanlint/tests/avoids_cpp_reserved.c +++ b/tools/ccanlint/tests/avoids_cpp_reserved.c @@ -13,7 +13,7 @@ #include #include -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -34,7 +34,8 @@ static struct ccan_file *main_header(struct manifest *m) } static void check_headers_no_cpp(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { char *contents; char *tmpsrc, *tmpobj, *cmdout; diff --git a/tools/ccanlint/tests/depends_accurate.c b/tools/ccanlint/tests/depends_accurate.c index 5549fc13..26943faa 100644 --- a/tools/ccanlint/tests/depends_accurate.c +++ b/tools/ccanlint/tests/depends_accurate.c @@ -70,7 +70,8 @@ static bool check_dep_includes(struct manifest *m, } static void check_depends_accurate(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct list_head *list; unsigned int i, core_deps, test_deps; diff --git a/tools/ccanlint/tests/depends_build.c b/tools/ccanlint/tests/depends_build.c index d4ebcb1d..24fb7ca3 100644 --- a/tools/ccanlint/tests/depends_build.c +++ b/tools/ccanlint/tests/depends_build.c @@ -15,7 +15,7 @@ #include #include "build.h" -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -76,7 +76,8 @@ char *build_submodule(struct manifest *m, const char *flags, } static void check_depends_built(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct list_head *list; diff --git a/tools/ccanlint/tests/depends_build_without_features.c b/tools/ccanlint/tests/depends_build_without_features.c index f9f582af..cacb5002 100644 --- a/tools/ccanlint/tests/depends_build_without_features.c +++ b/tools/ccanlint/tests/depends_build_without_features.c @@ -16,7 +16,7 @@ #include "reduce_features.h" #include "build.h" -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -24,7 +24,7 @@ static const char *can_build(struct manifest *m) } static void check_depends_built_without_features(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct list_head *list; diff --git a/tools/ccanlint/tests/depends_exist.c b/tools/ccanlint/tests/depends_exist.c index 088b1e0c..50f15422 100644 --- a/tools/ccanlint/tests/depends_exist.c +++ b/tools/ccanlint/tests/depends_exist.c @@ -46,7 +46,8 @@ static bool add_dep(struct manifest *m, /* FIXME: check this is still true once we reduce features. */ static void check_depends_exist(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { unsigned int i; char **deps; @@ -77,7 +78,7 @@ static void check_depends_exist(struct manifest *m, } static void check_test_depends_exist(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { unsigned int i; diff --git a/tools/ccanlint/tests/examples_compile.c b/tools/ccanlint/tests/examples_compile.c index 74586066..50862393 100644 --- a/tools/ccanlint/tests/examples_compile.c +++ b/tools/ccanlint/tests/examples_compile.c @@ -359,7 +359,8 @@ static char *strip_comment(const void *ctx, const char *orig_line) static char *mangle(struct manifest *m, char **lines) { char *ret, *use_funcs = NULL, *why; - bool in_function = false, fake_function = false, has_main = false; + bool in_function = false, fake_function = false, has_main = false, + fake_main = false; unsigned int i; ret = tal_fmt(m, @@ -393,6 +394,7 @@ static char *mangle(struct manifest *m, char **lines) fake_function = true; in_function = true; has_main = true; + fake_main = true; } else tal_append_fmt(&ret, "/* The example %s, so didn't wrap in main() */\n", @@ -429,6 +431,7 @@ static char *mangle(struct manifest *m, char **lines) /* This implies we start a function here. */ start_main(&ret, why); has_main = true; + fake_main = true; fake_function = true; in_function = true; } @@ -442,8 +445,9 @@ static char *mangle(struct manifest *m, char **lines) if (!has_main) { ret = tal_strcat(m, take(ret), "/* Need a main to link successfully. */\n" - "int main(void)\n{\n"); + "int main(int argc, char *argv[])\n{\n"); fake_function = true; + fake_main = true; } if (use_funcs) { @@ -460,8 +464,13 @@ static char *mangle(struct manifest *m, char **lines) tal_append_fmt(&ret, " %s\n", use_funcs); } + if (fake_main) + ret = tal_strcat(m, take(ret), + "(void)argc; (void)argv;\n"); + if (fake_function) - ret = tal_strcat(m, take(ret), "return 0;\n}\n"); + ret = tal_strcat(m, take(ret), + "return 0;\n}\n"); return ret; } @@ -485,7 +494,7 @@ static struct ccan_file *mangle_example(struct manifest *m, return NULL; contents = mangle(m, lines); - if (write(fd, contents, strlen(contents)) != strlen(contents)) { + if (write(fd, contents, strlen(contents)) != (int)strlen(contents)) { close(fd); return NULL; } @@ -550,7 +559,7 @@ static unsigned int try_compiling(struct manifest *m, } static void build_examples(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *i; char **prev = NULL; diff --git a/tools/ccanlint/tests/examples_exist.c b/tools/ccanlint/tests/examples_exist.c index c42a2e4e..61359596 100644 --- a/tools/ccanlint/tests/examples_exist.c +++ b/tools/ccanlint/tests/examples_exist.c @@ -45,7 +45,10 @@ static char *add_example(struct manifest *m, struct ccan_file *source, /* Add #line to demark where we are from, so errors are correct! */ linemarker = tal_fmt(f, "#line %i \"%s\"\n", example->srcline+2, source->fullname); - write(fd, linemarker, strlen(linemarker)); + if (write(fd, linemarker, strlen(linemarker)) != (int)strlen(linemarker)) { + close(fd); + return cast_const(char *, "Failure writing to temporary file"); + } for (i = 0; i < example->num_lines; i++) { if (write(fd, example->lines[i], strlen(example->lines[i])) @@ -62,7 +65,7 @@ static char *add_example(struct manifest *m, struct ccan_file *source, /* FIXME: We should have one example per function in header. */ static void extract_examples(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *f, *mainh = NULL; /* gcc complains uninitialized */ diff --git a/tools/ccanlint/tests/examples_relevant.c b/tools/ccanlint/tests/examples_relevant.c index ad718db3..1fc1f3bb 100644 --- a/tools/ccanlint/tests/examples_relevant.c +++ b/tools/ccanlint/tests/examples_relevant.c @@ -14,7 +14,7 @@ #include static void examples_relevant_check(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *f; diff --git a/tools/ccanlint/tests/examples_run.c b/tools/ccanlint/tests/examples_run.c index 8ea6a9bf..6c746b64 100644 --- a/tools/ccanlint/tests/examples_run.c +++ b/tools/ccanlint/tests/examples_run.c @@ -188,7 +188,7 @@ static char *unexpected(struct ccan_file *i, const char *input, } static void run_examples(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *i; struct list_head *list; diff --git a/tools/ccanlint/tests/hash_if.c b/tools/ccanlint/tests/hash_if.c index 78b8a967..e647ca21 100644 --- a/tools/ccanlint/tests/hash_if.c +++ b/tools/ccanlint/tests/hash_if.c @@ -15,7 +15,8 @@ #include static void check_hash_if(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct list_head *list; const char *explanation = diff --git a/tools/ccanlint/tests/headers_idempotent.c b/tools/ccanlint/tests/headers_idempotent.c index 1b2916bd..56c37ef7 100644 --- a/tools/ccanlint/tests/headers_idempotent.c +++ b/tools/ccanlint/tests/headers_idempotent.c @@ -178,7 +178,8 @@ static void check_idem(struct ccan_file *f, struct score *score) } static void check_idempotent(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct ccan_file *f; diff --git a/tools/ccanlint/tests/info_compiles.c b/tools/ccanlint/tests/info_compiles.c index 4ec07a0e..e1485963 100644 --- a/tools/ccanlint/tests/info_compiles.c +++ b/tools/ccanlint/tests/info_compiles.c @@ -16,7 +16,8 @@ #include static void check_info_compiles(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { char *info_c_file, *info, *output; int fd; diff --git a/tools/ccanlint/tests/info_documentation_exists.c b/tools/ccanlint/tests/info_documentation_exists.c index 47e72e57..c3f02226 100644 --- a/tools/ccanlint/tests/info_documentation_exists.c +++ b/tools/ccanlint/tests/info_documentation_exists.c @@ -25,7 +25,8 @@ static struct ccanlint info_documentation_exists = { .needs = "info_exists" }; -static void create_info_template_doc(struct manifest *m, struct score *score) +static void create_info_template_doc(struct manifest *m, + struct score *score UNNEEDED) { int fd; FILE *new; @@ -71,7 +72,7 @@ static void create_info_template_doc(struct manifest *m, struct score *score) } static void check_info_documentation_exists(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct list_head *infodocs = get_ccan_file_docs(m->info_file); diff --git a/tools/ccanlint/tests/info_exists.c b/tools/ccanlint/tests/info_exists.c index 9f6f2066..5e4459bc 100644 --- a/tools/ccanlint/tests/info_exists.c +++ b/tools/ccanlint/tests/info_exists.c @@ -14,7 +14,7 @@ #include static void check_has_info(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { if (m->info_file) { @@ -57,7 +57,8 @@ static const char template[] = " return 1;\n" "}\n"; -static void create_info_template(struct manifest *m, struct score *score) +static void create_info_template(struct manifest *m, + struct score *score UNNEEDED) { FILE *info; const char *filename; diff --git a/tools/ccanlint/tests/info_ported.c b/tools/ccanlint/tests/info_ported.c index 3479cfc4..80e347c7 100644 --- a/tools/ccanlint/tests/info_ported.c +++ b/tools/ccanlint/tests/info_ported.c @@ -27,8 +27,9 @@ static const char *can_build(struct manifest *m) return tal_fmt(m, "'_info ported' says '%s'", msg); } -static void check_info_ported(struct manifest *m, - unsigned int *timeleft, struct score *score) +static void check_info_ported(struct manifest *m UNNEEDED, + unsigned int *timeleft UNNEEDED, + struct score *score) { score->pass = true; score->score = 1; diff --git a/tools/ccanlint/tests/info_summary_single_line.c b/tools/ccanlint/tests/info_summary_single_line.c index 760c80b3..b45e00ba 100644 --- a/tools/ccanlint/tests/info_summary_single_line.c +++ b/tools/ccanlint/tests/info_summary_single_line.c @@ -4,7 +4,7 @@ #include static void check_info_summary_single_line(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct list_head *infodocs = get_ccan_file_docs(m->info_file); diff --git a/tools/ccanlint/tests/license_comment.c b/tools/ccanlint/tests/license_comment.c index abe0204e..ef865a4d 100644 --- a/tools/ccanlint/tests/license_comment.c +++ b/tools/ccanlint/tests/license_comment.c @@ -36,7 +36,8 @@ static bool line_has_license_flavour(const char *line, const char *shortname) } static void check_license_comment(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct list_head *list; diff --git a/tools/ccanlint/tests/license_depends_compat.c b/tools/ccanlint/tests/license_depends_compat.c index 10858d9b..4e73858f 100644 --- a/tools/ccanlint/tests/license_depends_compat.c +++ b/tools/ccanlint/tests/license_depends_compat.c @@ -11,7 +11,7 @@ #include static void check_license_depends_compat(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct manifest *i; diff --git a/tools/ccanlint/tests/license_exists.c b/tools/ccanlint/tests/license_exists.c index 85ff7985..3482bfee 100644 --- a/tools/ccanlint/tests/license_exists.c +++ b/tools/ccanlint/tests/license_exists.c @@ -94,7 +94,8 @@ static void handle_license_link(struct manifest *m, struct score *score) extern struct ccanlint license_exists; static void check_has_license(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { char buf[PATH_MAX]; ssize_t len; diff --git a/tools/ccanlint/tests/license_file_compat.c b/tools/ccanlint/tests/license_file_compat.c index 08cc31b9..e9273d24 100644 --- a/tools/ccanlint/tests/license_file_compat.c +++ b/tools/ccanlint/tests/license_file_compat.c @@ -12,7 +12,7 @@ #include static void check_license_file_compat(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct list_head *list; diff --git a/tools/ccanlint/tests/main_header_compiles.c b/tools/ccanlint/tests/main_header_compiles.c index f54c6173..1b741d4f 100644 --- a/tools/ccanlint/tests/main_header_compiles.c +++ b/tools/ccanlint/tests/main_header_compiles.c @@ -13,7 +13,7 @@ #include #include -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -34,7 +34,8 @@ static struct ccan_file *main_header(struct manifest *m) } static void check_includes_build(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { char *contents; char *tmpsrc, *tmpobj, *cmdout; diff --git a/tools/ccanlint/tests/main_header_exists.c b/tools/ccanlint/tests/main_header_exists.c index 2af9afc0..52a7e43c 100644 --- a/tools/ccanlint/tests/main_header_exists.c +++ b/tools/ccanlint/tests/main_header_exists.c @@ -14,7 +14,8 @@ #include static void check_has_main_header(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct ccan_file *f; diff --git a/tools/ccanlint/tests/module_builds.c b/tools/ccanlint/tests/module_builds.c index cb13a0b6..c33971e6 100644 --- a/tools/ccanlint/tests/module_builds.c +++ b/tools/ccanlint/tests/module_builds.c @@ -15,7 +15,7 @@ #include #include "build.h" -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -42,7 +42,7 @@ char *build_module(struct manifest *m, } static void do_build(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { char *errstr; diff --git a/tools/ccanlint/tests/module_links.c b/tools/ccanlint/tests/module_links.c index 403fff1a..9a2c0be5 100644 --- a/tools/ccanlint/tests/module_links.c +++ b/tools/ccanlint/tests/module_links.c @@ -14,7 +14,7 @@ #include #include -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -65,7 +65,8 @@ static char *lib_list(const struct manifest *m) } static void check_use_build(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { char *contents; char *tmpfile, *cmdout; diff --git a/tools/ccanlint/tests/no_trailing_whitespace.c b/tools/ccanlint/tests/no_trailing_whitespace.c index 60ecee79..74f759e7 100644 --- a/tools/ccanlint/tests/no_trailing_whitespace.c +++ b/tools/ccanlint/tests/no_trailing_whitespace.c @@ -21,7 +21,7 @@ static char *get_trailing_whitespace(const tal_t *ctx, const char *line) } static void check_trailing_whitespace(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct list_head *list; diff --git a/tools/ccanlint/tests/objects_build.c b/tools/ccanlint/tests/objects_build.c index d0bd7365..58f36437 100644 --- a/tools/ccanlint/tests/objects_build.c +++ b/tools/ccanlint/tests/objects_build.c @@ -15,7 +15,7 @@ #include #include "build.h" -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -74,7 +74,8 @@ void build_objects(struct manifest *m, } static void check_objs_build(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { const char *flags; diff --git a/tools/ccanlint/tests/objects_build_with_stringchecks.c b/tools/ccanlint/tests/objects_build_with_stringchecks.c index 1e99c100..083e7923 100644 --- a/tools/ccanlint/tests/objects_build_with_stringchecks.c +++ b/tools/ccanlint/tests/objects_build_with_stringchecks.c @@ -92,7 +92,7 @@ static struct ccan_file *get_main_header(struct manifest *m) } static void build_objects_with_stringchecks(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *i; diff --git a/tools/ccanlint/tests/objects_build_without_features.c b/tools/ccanlint/tests/objects_build_without_features.c index 4406842f..a32c0f62 100644 --- a/tools/ccanlint/tests/objects_build_without_features.c +++ b/tools/ccanlint/tests/objects_build_without_features.c @@ -4,7 +4,7 @@ #include "build.h" static void check_objs_build_without_features(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { const char *flags = tal_fmt(score, "%s %s", diff --git a/tools/ccanlint/tests/reduce_features.c b/tools/ccanlint/tests/reduce_features.c index b46c85fc..b49922b5 100644 --- a/tools/ccanlint/tests/reduce_features.c +++ b/tools/ccanlint/tests/reduce_features.c @@ -130,7 +130,8 @@ static struct htable_option *get_config_options(struct manifest *m) } static void do_reduce_features(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct htable_option *options_used, *options_avail, *options; struct htable_option_iter i; diff --git a/tools/ccanlint/tests/tests_compile.c b/tools/ccanlint/tests/tests_compile.c index f6995085..0bafcc64 100644 --- a/tools/ccanlint/tests/tests_compile.c +++ b/tools/ccanlint/tests/tests_compile.c @@ -16,7 +16,7 @@ #include "reduce_features.h" #include "tests_compile.h" -static const char *can_build(struct manifest *m) +static const char *can_build(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -54,7 +54,7 @@ char *test_obj_list(const struct manifest *m, bool link_with_module, return list; } -char *test_lib_list(const struct manifest *m, enum compile_type ctype) +char *test_lib_list(const struct manifest *m, enum compile_type ctype UNNEEDED) { unsigned int i; char **libs; @@ -211,7 +211,7 @@ struct ccanlint tests_compile = { REGISTER_TEST(tests_compile); -static const char *features_reduced(struct manifest *m) +static const char *features_reduced(struct manifest *m UNNEEDED) { if (features_were_reduced) return NULL; diff --git a/tools/ccanlint/tests/tests_exist.c b/tools/ccanlint/tests/tests_exist.c index 69e01df6..24c4d877 100644 --- a/tools/ccanlint/tests/tests_exist.c +++ b/tools/ccanlint/tests/tests_exist.c @@ -22,7 +22,7 @@ static struct ccanlint tests_exist = { }; REGISTER_TEST(tests_exist); -static void handle_no_tests(struct manifest *m, struct score *score) +static void handle_no_tests(struct manifest *m, struct score *score UNNEEDED) { FILE *run; struct ccan_file *i; @@ -104,7 +104,8 @@ static void handle_no_tests(struct manifest *m, struct score *score) } static void check_tests_exist(struct manifest *m, - unsigned int *timeleft, struct score *score) + unsigned int *timeleft UNNEEDED, + struct score *score) { struct stat st; char *test_dir = path_join(m, m->dir, "test"); diff --git a/tools/ccanlint/tests/tests_helpers_compile.c b/tools/ccanlint/tests/tests_helpers_compile.c index 6384bd38..0f728fb9 100644 --- a/tools/ccanlint/tests/tests_helpers_compile.c +++ b/tools/ccanlint/tests/tests_helpers_compile.c @@ -14,7 +14,7 @@ #include #include "reduce_features.h" -static const char *can_run(struct manifest *m) +static const char *can_run(struct manifest *m UNNEEDED) { if (safe_mode) return "Safe mode enabled"; @@ -33,7 +33,7 @@ static bool compile(struct manifest *m, } static void compile_test_helpers(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score, const char *flags, enum compile_type ctype) @@ -83,7 +83,7 @@ struct ccanlint tests_helpers_compile = { REGISTER_TEST(tests_helpers_compile); -static const char *features_reduced(struct manifest *m) +static const char *features_reduced(struct manifest *m UNNEEDED) { if (features_were_reduced) return NULL; diff --git a/tools/ccanlint/tests/tests_pass.c b/tools/ccanlint/tests/tests_pass.c index af71dbe4..ba6103de 100644 --- a/tools/ccanlint/tests/tests_pass.c +++ b/tools/ccanlint/tests/tests_pass.c @@ -139,8 +139,9 @@ static void run_under_debugger(struct manifest *m, struct score *score) command = tal_fmt(m, "gdb -ex 'break tap.c:139' -ex 'run' %s", first->file->compiled[COMPILE_NORMAL]); - if (system(command)) + if (system(command)) { doesnt_matter(); + } } struct ccanlint tests_pass = { diff --git a/tools/ccanlint/tests/tests_pass_valgrind.c b/tools/ccanlint/tests/tests_pass_valgrind.c index 2f4df18b..90e42349 100644 --- a/tools/ccanlint/tests/tests_pass_valgrind.c +++ b/tools/ccanlint/tests/tests_pass_valgrind.c @@ -158,7 +158,7 @@ static const char *concat(struct score *score, char *bits[]) /* FIXME: Run examples, too! */ static void do_run_tests_vg(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *i; @@ -199,7 +199,7 @@ static void do_run_tests_vg(struct manifest *m, } static void do_leakcheck_vg(struct manifest *m, - unsigned int *timeleft, + unsigned int *timeleft UNNEEDED, struct score *score) { struct ccan_file *i; @@ -255,8 +255,9 @@ static void run_under_debugger_vg(struct manifest *m, struct score *score) concat(score, per_file_options(&tests_pass_valgrind, first->file)), valgrind_suppress, first->file->compiled[COMPILE_NORMAL]); - if (system(command)) + if (system(command)) { doesnt_matter(); + } } struct ccanlint tests_pass_valgrind = { diff --git a/tools/ccanlint/tests/tests_pass_without_features.c b/tools/ccanlint/tests/tests_pass_without_features.c index 999c4eda..15b161ef 100644 --- a/tools/ccanlint/tests/tests_pass_without_features.c +++ b/tools/ccanlint/tests/tests_pass_without_features.c @@ -56,8 +56,9 @@ static void run_under_debugger(struct manifest *m, struct score *score) command = tal_fmt(m, "gdb -ex 'break tap.c:139' -ex 'run' %s", first->file->compiled[COMPILE_NOFEAT]); - if (system(command)) + if (system(command)) { doesnt_matter(); + } } struct ccanlint tests_pass_without_features = { diff --git a/tools/compile.c b/tools/compile.c index b88c1d86..e796e3f9 100644 --- a/tools/compile.c +++ b/tools/compile.c @@ -7,8 +7,12 @@ #ifndef CCAN_CFLAGS #define CCAN_CFLAGS DEFAULT_CCAN_CFLAGS #endif +#ifndef CCAN_OUTPUT_EXE_CFLAG +#define CCAN_OUTPUT_EXE_CFLAG DEFAULT_CCAN_OUTPUT_EXE_CFLAG +#endif const char *compiler = CCAN_COMPILER; const char *cflags = CCAN_CFLAGS; +const char *outexecflag = CCAN_OUTPUT_EXE_CFLAG; bool compile_verbose = false; @@ -37,8 +41,9 @@ bool compile_object(const void *ctx, const char *cfile, const char *ccandir, if (compile_verbose) printf("Compiling %s\n", outfile); return run_command(ctx, NULL, output, - "%s %s -I%s -c -o %s %s", - compiler, cflags, ccandir, outfile, cfile); + "%s %s -I%s -c %s%s %s", + compiler, cflags, ccandir, + outexecflag, outfile, cfile); } /* Compile and link single C file, with object files. @@ -51,7 +56,7 @@ bool compile_and_link(const void *ctx, const char *cfile, const char *ccandir, if (compile_verbose) printf("Compiling and linking %s\n", outfile); return run_command(ctx, NULL, output, - "%s %s -I%s -o %s %s %s %s", - compiler, cflags, - ccandir, outfile, cfile, objs, libs); + "%s %s -I%s %s%s %s %s %s", + compiler, cflags, ccandir, + outexecflag, outfile, cfile, objs, libs); } diff --git a/tools/configurator/configurator.c b/tools/configurator/configurator.c index 67dadc61..6ec30bd6 100644 --- a/tools/configurator/configurator.c +++ b/tools/configurator/configurator.c @@ -3,6 +3,9 @@ * * Copyright 2011 Rusty Russell . MIT license. * + * c12r_err, c12r_errx functions copied from ccan/err/err.c + * Copyright Rusty Russell . CC0 (Public domain) License. + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights @@ -21,23 +24,46 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ +#define _POSIX_C_SOURCE 200809L /* For pclose, popen, strdup */ + +#include #include +#include #include #include -#include -#include -#include -#include -#include -#include #include +#ifdef _MSC_VER +#define popen _popen +#define pclose _pclose +#endif + +#ifdef _MSC_VER +#define DEFAULT_COMPILER "cl" +/* Note: Dash options avoid POSIX path conversion when used under msys bash + * and are therefore preferred to slash (e.g. -nologo over /nologo) + * Note: Disable Warning 4200 "nonstandard extension used : zero-sized array + * in struct/union" for flexible array members. + */ +#define DEFAULT_FLAGS "-nologo -Zi -W4 -wd4200 " \ + "-D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS" +#define DEFAULT_OUTPUT_EXE_FLAG "-Fe:" +#else #define DEFAULT_COMPILER "cc" #define DEFAULT_FLAGS "-g3 -ggdb -Wall -Wundef -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes -Wold-style-definition" +#define DEFAULT_OUTPUT_EXE_FLAG "-o" +#endif #define OUTPUT_FILE "configurator.out" #define INPUT_FILE "configuratortest.c" +#ifdef _WIN32 +#define DIR_SEP "\\" +#else +#define DIR_SEP "/" +#endif + +static const char *progname = ""; static int verbose; enum test_style { @@ -62,7 +88,7 @@ struct test { }; static struct test tests[] = { - { "HAVE_32BIT_OFF_T", DEFINES_EVERYTHING|EXECUTE, NULL, NULL, + { "HAVE_32BIT_OFF_T", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL, "#include \n" "int main(void) {\n" " return sizeof(off_t) == 4 ? 0 : 1;\n" @@ -167,7 +193,7 @@ static struct test tests[] = { { "HAVE_COMPOUND_LITERALS", INSIDE_MAIN, NULL, NULL, "int *foo = (int[]) { 1, 2, 3, 4 };\n" "return foo[0] ? 0 : 1;" }, - { "HAVE_FCHDIR", DEFINES_EVERYTHING|EXECUTE, NULL, NULL, + { "HAVE_FCHDIR", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL, "#include \n" "#include \n" "#include \n" @@ -188,7 +214,7 @@ static struct test tests[] = { " if (arg == 4)\n" " warnx(\"warn %u\", arg);\n" "}\n" }, - { "HAVE_FILE_OFFSET_BITS", DEFINES_EVERYTHING|EXECUTE, + { "HAVE_FILE_OFFSET_BITS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, "HAVE_32BIT_OFF_T", NULL, "#define _FILE_OFFSET_BITS 64\n" "#include \n" @@ -196,8 +222,9 @@ static struct test tests[] = { " return sizeof(off_t) == 8 ? 0 : 1;\n" "}\n" }, { "HAVE_FOR_LOOP_DECLARATION", INSIDE_MAIN, NULL, NULL, - "for (int i = 0; i < argc; i++) { return 0; };\n" - "return 1;" }, + "int ret = 1;\n" + "for (int i = 0; i < argc; i++) { ret = 0; };\n" + "return ret;" }, { "HAVE_FLEXIBLE_ARRAY_MEMBER", OUTSIDE_MAIN, NULL, NULL, "struct foo { unsigned int x; int arr[]; };" }, { "HAVE_GETPAGESIZE", DEFINES_FUNC, NULL, NULL, @@ -234,7 +261,7 @@ static struct test tests[] = { "static void *func(int fd) {\n" " return mmap(0, 65536, PROT_READ, MAP_SHARED, fd, 0);\n" "}" }, - { "HAVE_PROC_SELF_MAPS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL, + { "HAVE_PROC_SELF_MAPS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL, "#include \n" "#include \n" "#include \n" @@ -271,7 +298,8 @@ static struct test tests[] = { " return __stop_mysec - __start_mysec;\n" "}\n" }, { "HAVE_STACK_GROWS_UPWARDS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL, - "static long nest(const void *base, unsigned int i)\n" + "#include \n" + "static ptrdiff_t nest(const void *base, unsigned int i)\n" "{\n" " if (i == 0)\n" " return (const char *)&i - (const char *)base;\n" @@ -319,7 +347,7 @@ static struct test tests[] = { "-Werror -fopenmp" }, { "HAVE_VALGRIND_MEMCHECK_H", OUTSIDE_MAIN, NULL, NULL, "#include \n" }, - { "HAVE_UCONTEXT", DEFINES_EVERYTHING|EXECUTE, + { "HAVE_UCONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL, "#include \n" "static int x = 0;\n" @@ -340,7 +368,7 @@ static struct test tests[] = { " return (x == 3) ? 0 : 1;\n" "}\n" }, - { "HAVE_POINTER_SAFE_MAKECONTEXT", DEFINES_EVERYTHING|EXECUTE, + { "HAVE_POINTER_SAFE_MAKECONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, "HAVE_UCONTEXT", NULL, "#include \n" "#include \n" @@ -367,71 +395,95 @@ static struct test tests[] = { }, }; -static char *grab_fd(int fd) +static void c12r_err(int eval, const char *fmt, ...) +{ + int err_errno = errno; + va_list ap; + + fprintf(stderr, "%s: ", progname); + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, ": %s\n", strerror(err_errno)); + exit(eval); +} + +static void c12r_errx(int eval, const char *fmt, ...) { - int ret; - size_t max, size = 0; + va_list ap; + + fprintf(stderr, "%s: ", progname); + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "\n"); + exit(eval); +} + +static size_t fcopy(FILE *fsrc, FILE *fdst) +{ + char buffer[BUFSIZ]; + size_t rsize, wsize; + size_t copied = 0; + + while ((rsize = fread(buffer, 1, BUFSIZ, fsrc)) > 0) { + wsize = fwrite(buffer, 1, rsize, fdst); + copied += wsize; + if (wsize != rsize) + break; + } + + return copied; +} + +static char *grab_stream(FILE *file) +{ + size_t max, ret, size = 0; char *buffer; - max = 16384; - buffer = malloc(max+1); - while ((ret = read(fd, buffer + size, max - size)) > 0) { + max = BUFSIZ; + buffer = malloc(max); + while ((ret = fread(buffer+size, 1, max - size, file)) == max - size) { size += ret; - if (size == max) - buffer = realloc(buffer, max *= 2); + buffer = realloc(buffer, max *= 2); } - if (ret < 0) - err(1, "reading from command"); + size += ret; + if (ferror(file)) + c12r_err(1, "reading from command"); buffer[size] = '\0'; return buffer; } static char *run(const char *cmd, int *exitstatus) { - pid_t pid; - int p[2]; + static const char redir[] = " 2>&1"; + size_t cmdlen; + char *cmdredir; + FILE *cmdout; char *ret; - int status; - if (pipe(p) != 0) - err(1, "creating pipe"); - - pid = fork(); - if (pid == -1) - err(1, "forking"); - - if (pid == 0) { - if (dup2(p[1], STDOUT_FILENO) != STDOUT_FILENO - || dup2(p[1], STDERR_FILENO) != STDERR_FILENO - || close(p[0]) != 0 - || close(STDIN_FILENO) != 0 - || open("/dev/null", O_RDONLY) != STDIN_FILENO) - exit(128); - - status = system(cmd); - if (WIFEXITED(status)) - exit(WEXITSTATUS(status)); - /* Here's a hint... */ - exit(128 + WTERMSIG(status)); - } + cmdlen = strlen(cmd); + cmdredir = malloc(cmdlen + sizeof(redir)); + memcpy(cmdredir, cmd, cmdlen); + memcpy(cmdredir + cmdlen, redir, sizeof(redir)); + + cmdout = popen(cmdredir, "r"); + if (!cmdout) + c12r_err(1, "popen \"%s\"", cmdredir); - close(p[1]); - ret = grab_fd(p[0]); - /* This shouldn't fail... */ - if (waitpid(pid, &status, 0) != pid) - err(1, "Failed to wait for child"); - close(p[0]); - if (WIFEXITED(status)) - *exitstatus = WEXITSTATUS(status); - else - *exitstatus = -WTERMSIG(status); + free(cmdredir); + + ret = grab_stream(cmdout); + *exitstatus = pclose(cmdout); return ret; } -static char *connect_args(const char *argv[], const char *extra) +static char *connect_args(const char *argv[], const char *outflag, + const char *files) { - unsigned int i, len = strlen(extra) + 1; + unsigned int i; char *ret; + size_t len = strlen(outflag) + strlen(files) + 1; for (i = 1; argv[i]; i++) len += 1 + strlen(argv[i]); @@ -441,10 +493,12 @@ static char *connect_args(const char *argv[], const char *extra) for (i = 1; argv[i]; i++) { strcpy(ret + len, argv[i]); len += strlen(argv[i]); - if (argv[i+1]) + if (argv[i+1] || *outflag) ret[len++] = ' '; } - strcpy(ret + len, extra); + strcpy(ret + len, outflag); + len += strlen(outflag); + strcpy(ret + len, files); return ret; } @@ -483,7 +537,7 @@ static bool run_test(const char *cmd, struct test *test) char *dep; /* Space-separated dependencies, could be ! for inverse. */ - while ((len = strcspn(deps, " "))) { + while ((len = strcspn(deps, " ")) != 0) { bool positive = true; if (deps[len]) { dep = strdup(deps); @@ -509,9 +563,9 @@ static bool run_test(const char *cmd, struct test *test) } } - outf = fopen(INPUT_FILE, "w"); + outf = fopen(INPUT_FILE, verbose > 1 ? "w+" : "w"); if (!outf) - err(1, "creating %s", INPUT_FILE); + c12r_err(1, "creating %s", INPUT_FILE); fprintf(outf, "%s", PRE_BOILERPLATE); switch (test->style & ~(EXECUTE|MAY_NOT_COMPILE)) { @@ -540,11 +594,13 @@ static bool run_test(const char *cmd, struct test *test) abort(); } - fclose(outf); - if (verbose > 1) - if (system("cat " INPUT_FILE) == -1) - ; + if (verbose > 1) { + fseek(outf, 0, SEEK_SET); + fcopy(outf, stdout); + } + + fclose(outf); newcmd = strdup(cmd); @@ -576,8 +632,8 @@ static bool run_test(const char *cmd, struct test *test) status ? "fail" : "warning", test->name, status, output); if ((test->style & EXECUTE) && !(test->style & MAY_NOT_COMPILE)) - errx(1, "Test for %s did not compile:\n%s", - test->name, output); + c12r_errx(1, "Test for %s did not compile:\n%s", + test->name, output); test->answer = false; free(output); } else { @@ -585,10 +641,10 @@ static bool run_test(const char *cmd, struct test *test) free(output); /* We run INSIDE_MAIN tests for sanity checking. */ if ((test->style & EXECUTE) || (test->style & INSIDE_MAIN)) { - output = run("./" OUTPUT_FILE, &status); + output = run("." DIR_SEP OUTPUT_FILE, &status); if (!(test->style & EXECUTE) && status != 0) - errx(1, "Test for %s failed with %i:\n%s", - test->name, status, output); + c12r_errx(1, "Test for %s failed with %i:\n%s", + test->name, status, output); if (verbose && status) printf("%s exited %i\n", test->name, status); free(output); @@ -611,36 +667,53 @@ int main(int argc, const char *argv[]) unsigned int i; const char *default_args[] = { "", DEFAULT_COMPILER, DEFAULT_FLAGS, NULL }; + const char *outflag = DEFAULT_OUTPUT_EXE_FLAG; + + if (argc > 0) + progname = argv[0]; - if (argc > 1) { + while (argc > 1) { if (strcmp(argv[1], "--help") == 0) { - printf("Usage: configurator [-v] [ ...]\n" - " will have \"-o \" appended\n" - "Default: %s %s\n", - DEFAULT_COMPILER, DEFAULT_FLAGS); + printf("Usage: configurator [-v] [-O] [ ...]\n" + " will have \" \" appended\n" + "Default: %s %s %s\n", + DEFAULT_COMPILER, DEFAULT_FLAGS, + DEFAULT_OUTPUT_EXE_FLAG); exit(0); } - if (strcmp(argv[1], "-v") == 0) { + if (strncmp(argv[1], "-O", 2) == 0) { + argc--; + argv++; + outflag = argv[1] + 2; + if (!*outflag) { + fprintf(stderr, + "%s: option requires an argument -- O\n", + argv[0]); + exit(1); + } + } else if (strcmp(argv[1], "-v") == 0) { argc--; argv++; - verbose = 1; + verbose++; } else if (strcmp(argv[1], "-vv") == 0) { argc--; argv++; - verbose = 2; + verbose += 2; + } else { + break; } } if (argc == 1) argv = default_args; - cmd = connect_args(argv, " -o " OUTPUT_FILE " " INPUT_FILE); + cmd = connect_args(argv, outflag, OUTPUT_FILE " " INPUT_FILE); for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) run_test(cmd, &tests[i]); free(cmd); - unlink(OUTPUT_FILE); - unlink(INPUT_FILE); + remove(OUTPUT_FILE); + remove(INPUT_FILE); printf("/* Generated by CCAN configurator */\n" "#ifndef CCAN_CONFIG_H\n" @@ -649,9 +722,10 @@ int main(int argc, const char *argv[]) printf("#define _GNU_SOURCE /* Always use GNU extensions. */\n"); printf("#endif\n"); printf("#define CCAN_COMPILER \"%s\"\n", argv[1]); - cmd = connect_args(argv+1, ""); - printf("#define CCAN_CFLAGS \"%s\"\n\n", cmd); + cmd = connect_args(argv + 1, "", ""); + printf("#define CCAN_CFLAGS \"%s\"\n", cmd); free(cmd); + printf("#define CCAN_OUTPUT_EXE_CFLAG \"%s\"\n\n", outflag); /* This one implies "#include name, (*b)->name); } diff --git a/tools/tools.h b/tools/tools.h index 3b5c4bed..668c91ad 100644 --- a/tools/tools.h +++ b/tools/tools.h @@ -11,6 +11,7 @@ /* These are the defaults. */ #define DEFAULT_CCAN_COMPILER "cc" #define DEFAULT_CCAN_CFLAGS "-g" +#define DEFAULT_CCAN_OUTPUT_EXE_CFLAG "-o" #define IDENT_CHARS "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \ "abcdefghijklmnopqrstuvwxyz" \ @@ -20,8 +21,9 @@ #define COVERAGE_CFLAGS "-fprofile-arcs -ftest-coverage" -/* Actual compiler and cflags (defaults to CCAN_COMPILER and CCAN_CFLAGS). */ -extern const char *compiler, *cflags; +/* Actual compiler and cflags + * (defaults to CCAN_COMPILER, CCAN_CFLAGS, CCAN_OUTPUT_EXE_CFLAG). */ +extern const char *compiler, *cflags, *outexecflag; /* This compiles up the _info file into a temporary. */ char *compile_info(const void *ctx, const char *dir);