Browse Source

fix missing li prefixes

personal/stbuehler/wip
Stefan Bühler 9 years ago
parent
commit
a937bd437a
  1. 2
      include/lighttpd/buffer.h
  2. 21
      include/lighttpd/log.h
  3. 12
      include/lighttpd/mempool.h
  4. 3
      include/lighttpd/plugin.h
  5. 4
      include/lighttpd/settings.h
  6. 2
      include/lighttpd/throttle.h
  7. 2
      include/lighttpd/virtualrequest.h
  8. 6
      src/common/buffer.c
  9. 20
      src/common/mempool.c
  10. 2
      src/main/actions.c
  11. 4
      src/main/chunk.c
  12. 6
      src/main/condition.c
  13. 2
      src/main/lighttpd_worker.c
  14. 2
      src/main/log.c
  15. 2
      src/main/response.c
  16. 2
      src/main/subrequest_lua.c
  17. 6
      src/main/throttle.c
  18. 2
      src/main/worker.c
  19. 2
      src/modules/fastcgi_stream.c
  20. 2
      src/modules/mod_cache_disk_etag.c
  21. 2
      src/modules/mod_deflate.c
  22. 2
      src/modules/mod_memcached.c
  23. 2
      src/modules/mod_scgi.c
  24. 2
      src/modules/mod_throttle.c
  25. 6
      src/unittests/test-range-parser.c

2
include/lighttpd/buffer.h

@ -11,7 +11,7 @@ struct liBuffer {
gsize alloc_size;
gsize used;
gint refcount;
mempool_ptr mptr;
liMempoolPtr mptr;
};
/* shared buffer; free memory after last reference is released */

21
include/lighttpd/log.h

@ -21,30 +21,30 @@
/* at least one of srv and wrk must not be NULL. log_map may be NULL. */
#define _SEGFAULT(srv, wrk, log_map, fmt, ...) \
do { \
li_log_write(srv, NULL, NULL, LI_LOG_LEVEL_ABORT, LOG_FLAG_TIMESTAMP, "(crashing) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__); \
li_log_write(srv, NULL, NULL, LI_LOG_LEVEL_ABORT, LI_LOG_FLAG_TIMESTAMP, "(crashing) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__); \
/* VALGRIND_PRINTF_BACKTRACE(fmt, __VA_ARGS__); */\
abort();\
} while(0)
#define _ERROR(srv, wrk, ctx, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_ERROR, LOG_FLAG_TIMESTAMP, "(error) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_ERROR, LI_LOG_FLAG_TIMESTAMP, "(error) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
#define _WARNING(srv, wrk, ctx, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_WARNING, LOG_FLAG_TIMESTAMP, "(warning) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_WARNING, LI_LOG_FLAG_TIMESTAMP, "(warning) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
#define _INFO(srv, wrk, ctx, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_INFO, LOG_FLAG_TIMESTAMP, "(info) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_INFO, LI_LOG_FLAG_TIMESTAMP, "(info) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
#define _DEBUG(srv, wrk, ctx, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_DEBUG, LOG_FLAG_TIMESTAMP, "(debug) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_DEBUG, LI_LOG_FLAG_TIMESTAMP, "(debug) %s.%d: "fmt, LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__)
#define _BACKEND(srv, wrk, ctx, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_BACKEND, LOG_FLAG_TIMESTAMP, fmt, __VA_ARGS__)
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_BACKEND, LI_LOG_FLAG_TIMESTAMP, fmt, __VA_ARGS__)
#define _BACKEND_LINES(srv, wrk, ctx, txt, fmt, ...) \
li_log_split_lines_(srv, wrk, ctx, LI_LOG_LEVEL_BACKEND, LOG_FLAG_TIMESTAMP, txt, fmt, __VA_ARGS__)
li_log_split_lines_(srv, wrk, ctx, LI_LOG_LEVEL_BACKEND, LI_LOG_FLAG_TIMESTAMP, txt, fmt, __VA_ARGS__)
#define _GERROR(srv, wrk, ctx, error, fmt, ...) \
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_ERROR, LOG_FLAG_TIMESTAMP, "(error) %s.%d: " fmt "\n %s", LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__, error ? error->message : "Empty GError")
li_log_write(srv, wrk, ctx, LI_LOG_LEVEL_ERROR, LI_LOG_FLAG_TIMESTAMP, "(error) %s.%d: " fmt "\n %s", LI_REMOVE_PATH(__FILE__), __LINE__, __VA_ARGS__, error ? error->message : "Empty GError")
#define VR_SEGFAULT(vr, fmt, ...) _SEGFAULT(vr->wrk->srv, vr->wrk, &vr->log_context, fmt, __VA_ARGS__)
#define VR_ERROR(vr, fmt, ...) _ERROR(vr->wrk->srv, vr->wrk, &vr->log_context, fmt, __VA_ARGS__)
@ -74,9 +74,8 @@
#define GERROR(srv, error, fmt, ...) _GERROR(srv, NULL, NULL, error, fmt, __VA_ARGS__)
/* flags for li_log_write */
#define LOG_FLAG_NONE (0x0) /* default flag */
#define LOG_FLAG_TIMESTAMP (0x1) /* prepend a timestamp to the log message */
#define LOG_FLAG_NOLOCK (0x1 << 1) /* for internal use only */
#define LI_LOG_FLAG_NONE (0x0) /* default flag */
#define LI_LOG_FLAG_TIMESTAMP (0x1) /* prepend a timestamp to the log message */
/* embed this into structures that should have their own log context, like liVRequest and liServer.logs */
struct liLogContext {

12
include/lighttpd/mempool.h

@ -3,18 +3,18 @@
#include <lighttpd/settings.h>
typedef struct mempool_ptr mempool_ptr;
struct mempool_ptr {
typedef struct liMempoolPtr liMempoolPtr;
struct liMempoolPtr {
void *priv_data; /* private data for internal management */
void *data; /* real pointer (result of alloc) */
};
LI_API gsize mempool_align_page_size(gsize size);
LI_API mempool_ptr mempool_alloc(gsize size);
LI_API gsize li_mempool_align_page_size(gsize size);
LI_API liMempoolPtr li_mempool_alloc(gsize size);
/* you cannot release parts from an allocated chunk; so you _have_ to remember the size from the alloc */
LI_API void mempool_free(mempool_ptr ptr, gsize size);
LI_API void li_mempool_free(liMempoolPtr ptr, gsize size);
LI_API void mempool_cleanup();
LI_API void li_mempool_cleanup();
#endif

3
include/lighttpd/plugin.h

@ -5,9 +5,6 @@
#error Please include <lighttpd/base.h> instead of this file
#endif
#define INIT_FUNC(x) \
LI_EXPORT void * x(server *srv, plugin *)
typedef void (*liPluginInitCB) (liServer *srv, liPlugin *p, gpointer userdata);
typedef void (*liPluginFreeCB) (liServer *srv, liPlugin *p);
typedef gboolean (*liPluginParseOptionCB) (liServer *srv, liWorker *wrk, liPlugin *p, size_t ndx, liValue *val, liOptionValue *oval);

4
include/lighttpd/settings.h

@ -47,8 +47,8 @@
#include <glib.h>
#include <gmodule.h>
#define L_GOFFSET_FORMAT G_GINT64_FORMAT
#define L_GOFFSET_MODIFIER G_GINT64_MODIFIER
#define LI_GOFFSET_FORMAT G_GINT64_FORMAT
#define LI_GOFFSET_MODIFIER G_GINT64_MODIFIER
#define CONST_STR_LEN(x) (x), (sizeof(x) - 1)
#define CONST_USTR_LEN(x) ((const guchar*) (x)), (sizeof(x) - 1)

2
include/lighttpd/throttle.h

@ -3,7 +3,7 @@
#include <lighttpd/base.h>
#define THROTTLE_GRANULARITY 200 /* defines how frequently (in milliseconds) a magazine is refilled */
#define LI_THROTTLE_GRANULARITY 200 /* defines how frequently (in milliseconds) a magazine is refilled */
typedef void (*liThrottleNotifyCB)(liThrottleState *state, gpointer data);

2
include/lighttpd/virtualrequest.h

@ -111,7 +111,7 @@ struct liVRequest {
GPtrArray *stat_cache_entries;
};
#define VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr) \
#define LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr) \
do { \
if (vr->state == LI_VRS_HANDLE_REQUEST_HEADERS) { \
VR_ERROR(vr, "%s", "Cannot wait for response headers as no backend handler found - fix your config"); \

6
src/common/buffer.c

@ -4,7 +4,7 @@
static void _buffer_init(liBuffer *buf, gsize alloc_size) {
buf->alloc_size = alloc_size;
buf->used = 0;
buf->mptr = mempool_alloc(alloc_size);
buf->mptr = li_mempool_alloc(alloc_size);
buf->addr = buf->mptr.data;
}
@ -21,7 +21,7 @@ static void _buffer_destroy(liBuffer *buf) {
if (NULL == buf->mptr.data) {
g_slice_free1(buf->alloc_size, buf->addr);
} else {
mempool_free(buf->mptr, buf->alloc_size);
li_mempool_free(buf->mptr, buf->alloc_size);
buf->addr = NULL;
buf->mptr.data = NULL; buf->mptr.priv_data = NULL;
buf->used = buf->alloc_size = 0;
@ -33,7 +33,7 @@ static void _buffer_destroy(liBuffer *buf) {
liBuffer* li_buffer_new(gsize max_size) {
liBuffer *buf = g_slice_new0(liBuffer);
_buffer_init(buf, mempool_align_page_size(max_size));
_buffer_init(buf, li_mempool_align_page_size(max_size));
buf->refcount = 1;
return buf;
}

20
src/common/mempool.c

@ -22,21 +22,21 @@
#ifdef MEMPOOL_MALLOC
mempool_ptr mempool_alloc(gsize size) {
mempool_ptr ptr = { NULL, g_malloc(size) };
liMempoolPtr li_mempool_alloc(gsize size) {
liMempoolPtr ptr = { NULL, g_malloc(size) };
return ptr;
}
void mempool_free(mempool_ptr ptr, gsize size) {
void li_mempool_free(liMempoolPtr ptr, gsize size) {
UNUSED(size);
if (!ptr.data) return;
g_free(ptr.data);
}
void mempool_cleanup() {
void li_mempool_cleanup() {
}
gsize mempool_align_page_size(gsize size) {
gsize li_mempool_align_page_size(gsize size) {
return size;
}
@ -156,7 +156,7 @@ static inline gsize mp_align_size(gsize size) {
return size;
}
gsize mempool_align_page_size(gsize size) {
gsize li_mempool_align_page_size(gsize size) {
if (G_UNLIKELY(!mp_initialized)) {
mempool_init();
}
@ -385,8 +385,8 @@ done:
return pool;
}
mempool_ptr mempool_alloc(gsize size) {
mempool_ptr ptr = { NULL, NULL };
liMempoolPtr li_mempool_alloc(gsize size) {
liMempoolPtr ptr = { NULL, NULL };
mp_pool *pool;
mp_magazine *mag;
guint i;
@ -460,7 +460,7 @@ found_mag:
return ptr;
}
void mempool_free(mempool_ptr ptr, gsize size) {
void li_mempool_free(liMempoolPtr ptr, gsize size) {
mp_magazine *mag;
if (!ptr.data) return;
@ -481,7 +481,7 @@ void mempool_free(mempool_ptr ptr, gsize size) {
mp_mag_release(mag); /* keep track of chunk count; release always after unlock! */
}
void mempool_cleanup() {
void li_mempool_cleanup() {
/* "Force" thread-private cleanup */
mp_pools *pools;

2
src/main/actions.c

@ -302,7 +302,7 @@ liHandlerResult li_action_execute(liVRequest *vr) {
*/
if (ase->act->type == LI_ACTION_TBALANCER) {
/* wait until we found a backend */
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
}
action_stack_pop(srv, vr, as);
continue;

4
src/main/chunk.c

@ -379,12 +379,12 @@ static void cqlimit_update(liChunkQueue *cq, goffset d) {
cq->mem_usage += d;
assert(cq->mem_usage >= 0);
cql = cq->limit;
/* g_printerr("cqlimit_update: cq->mem_usage: %"L_GOFFSET_FORMAT"\n", cq->mem_usage); */
/* g_printerr("cqlimit_update: cq->mem_usage: %"LI_GOFFSET_FORMAT"\n", cq->mem_usage); */
if (!cql) return;
cql->current += d;
assert(cql->current >= 0);
/* g_printerr("cqlimit_update: cql->current: %"L_GOFFSET_FORMAT", cql->limit: %"L_GOFFSET_FORMAT"\n", cql->current, cql->limit); */
/* g_printerr("cqlimit_update: cql->current: %"LI_GOFFSET_FORMAT", cql->limit: %"LI_GOFFSET_FORMAT"\n", cql->current, cql->limit); */
if (cql->locked) {
if (cql->limit <= 0 || cql->current < cql->limit) {
cqlimit_unlock(cql);

6
src/main/condition.c

@ -168,7 +168,7 @@ liHandlerResult li_condition_get_value(GString *tmpstr, liVRequest *vr, liCondit
res->data.str = vr->physical.pathinfo->str;
break;
case LI_COMP_RESPONSE_STATUS:
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
res->match_type = LI_COND_VALUE_HINT_NUMBER;
res->data.number = vr->response.http_status;
break;
@ -178,7 +178,7 @@ liHandlerResult li_condition_get_value(GString *tmpstr, liVRequest *vr, liCondit
res->data.str = tmpstr->str;
break;
case LI_COMP_RESPONSE_HEADER:
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
res->match_type = LI_COND_VALUE_HINT_STRING;
li_http_header_get_all(tmpstr, vr->response.headers, GSTR_LEN(lvalue->key));
res->data.str = tmpstr->str;
@ -206,7 +206,7 @@ gchar const* li_condition_value_to_string(GString *tmpstr, liConditionValue *val
case LI_COND_VALUE_HINT_BOOL:
return value->data.bool ? "TRUE" : "FALSE";
case LI_COND_VALUE_HINT_NUMBER:
g_string_printf(tmpstr, "%"L_GOFFSET_FORMAT, value->data.number);
g_string_printf(tmpstr, "%"LI_GOFFSET_FORMAT, value->data.number);
return tmpstr->str;
case LI_COND_VALUE_HINT_SOCKADDR:
li_sockaddr_to_string(value->data.addr, tmpstr, TRUE);

2
src/main/lighttpd_worker.c

@ -148,7 +148,7 @@ int main(int argc, char *argv[]) {
if (free_config_path)
g_free(config_path);
mempool_cleanup();
li_mempool_cleanup();
return 0;
}

2
src/main/log.c

@ -339,7 +339,7 @@ static void log_watcher_cb(liEventBase *watcher, int events) {
gssize bytes_written = 0;
gssize write_res;
if (log_entry->flags & LOG_FLAG_TIMESTAMP) {
if (log_entry->flags & LI_LOG_FLAG_TIMESTAMP) {
GString *ts = log_timestamp_format(srv);
g_string_prepend_c(msg, ' ');
g_string_prepend_len(msg, GSTR_LEN(ts));

2
src/main/response.c

@ -58,7 +58,7 @@ void li_response_send_headers(liVRequest *vr, liChunkQueue *raw_out, liChunkQueu
} else if (response_complete) {
if (vr->request.http_method != LI_HTTP_METHOD_HEAD || response_body->length > 0) {
/* do not send content-length: 0 if backend already skipped content generation for HEAD */
g_string_printf(vr->wrk->tmp_str, "%"L_GOFFSET_FORMAT, response_body->length);
g_string_printf(vr->wrk->tmp_str, "%"LI_GOFFSET_FORMAT, response_body->length);
li_http_header_overwrite(vr->response.headers, CONST_STR_LEN("Content-Length"), GSTR_LEN(vr->wrk->tmp_str));
}
} else if (vr->coninfo->keep_alive && vr->request.http_version == LI_HTTP_VERSION_1_1) {

2
src/main/subrequest_lua.c

@ -276,7 +276,7 @@ static void subvr_handle_check_io(liVRequest *vr) {
subvr_check(vr);
}
const liConCallbacks subrequest_callbacks = {
static const liConCallbacks subrequest_callbacks = {
subvr_handle_response_error,
subvr_handle_check_io
};

6
src/main/throttle.c

@ -103,12 +103,12 @@ static void throttle_pool_rearm(liWorker *wrk, liThrottlePool *pool, guint now)
guint last = g_atomic_int_get((gint*) &pool->last_rearm);
guint time_diff = now - last;
if (G_UNLIKELY(time_diff >= THROTTLE_GRANULARITY)) {
if (G_UNLIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
g_mutex_lock(pool->rearm_mutex);
/* check again */
last = g_atomic_int_get((gint*) &pool->last_rearm);
time_diff = now - last;
if (G_LIKELY(time_diff >= THROTTLE_GRANULARITY)) {
if (G_LIKELY(time_diff >= LI_THROTTLE_GRANULARITY)) {
S_throttle_pool_rearm_workers(pool, wrk->srv->worker_count, time_diff);
g_atomic_int_set((gint*) &pool->last_rearm, now);
}
@ -172,7 +172,7 @@ guint li_throttle_query(liWorker *wrk, liThrottleState *state, guint interested,
/* also try to balance negative magazine */
fill = interested - state->magazine;
if (state->single_rate != 0) {
if (now - state->single_last_rearm >= THROTTLE_GRANULARITY) {
if (now - state->single_last_rearm >= LI_THROTTLE_GRANULARITY) {
guint single_fill = ((guint64) state->single_rate) * 1000u / (now - state->single_last_rearm);
state->single_last_rearm = now;
if (state->single_burst - state->single_magazine < single_fill) {

2
src/main/worker.c

@ -308,7 +308,7 @@ liWorker* li_worker_new(liServer *srv, struct ev_loop *loop) {
li_waitqueue_init(&wrk->io_timeout_queue, &wrk->loop, worker_io_timeout_cb, srv->io_timeout, wrk);
/* throttling */
li_waitqueue_init(&wrk->throttle_queue, &wrk->loop, li_throttle_waitqueue_cb, ((gdouble)THROTTLE_GRANULARITY) / 1000, wrk);
li_waitqueue_init(&wrk->throttle_queue, &wrk->loop, li_throttle_waitqueue_cb, ((gdouble)LI_THROTTLE_GRANULARITY) / 1000, wrk);
wrk->tasklets = li_tasklet_pool_new(&wrk->loop, srv->tasklet_pool_threads);

2
src/modules/fastcgi_stream.c

@ -443,7 +443,7 @@ static void fastcgi_env_create(liVRequest *vr, liEnvironmentDup *envdup, GByteAr
fastcgi_env_add(buf, envdup, CONST_STR_LEN("REMOTE_ADDR"), GSTR_LEN(coninfo->remote_addr_str));
if (vr->request.content_length > 0) {
g_string_printf(tmp, "%" L_GOFFSET_MODIFIER "i", vr->request.content_length);
g_string_printf(tmp, "%" LI_GOFFSET_MODIFIER "i", vr->request.content_length);
fastcgi_env_add(buf, envdup, CONST_STR_LEN("CONTENT_LENGTH"), GSTR_LEN(tmp));
}

2
src/modules/mod_cache_disk_etag.c

@ -240,7 +240,7 @@ static liHandlerResult cache_etag_handle(liVRequest *vr, gpointer param, gpointe
if (!cfile) {
if (vr->request.http_method != LI_HTTP_METHOD_GET) return LI_HANDLER_GO_ON;
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
if (vr->response.http_status != 200) return LI_HANDLER_GO_ON;

2
src/modules/mod_deflate.c

@ -546,7 +546,7 @@ static liHandlerResult deflate_handle(liVRequest *vr, gpointer param, gpointer *
UNUSED(context);
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
/* disable compression for some http status types. */
switch(vr->response.http_status) {

2
src/modules/mod_memcached.c

@ -524,7 +524,7 @@ static liHandlerResult mc_handle_store(liVRequest *vr, gpointer param, gpointer
memcache_filter *mf;
UNUSED(context);
VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
LI_VREQUEST_WAIT_FOR_RESPONSE_HEADERS(vr);
if (vr->response.http_status != 200) return LI_HANDLER_GO_ON;

2
src/modules/mod_scgi.c

@ -75,7 +75,7 @@ static void scgi_env_create(liVRequest *vr, liEnvironmentDup *envdup, GByteArray
g_assert(vr->request.content_length >= 0);
if (vr->request.content_length >= 0) {
g_string_printf(tmp, "%" L_GOFFSET_MODIFIER "i", vr->request.content_length);
g_string_printf(tmp, "%" LI_GOFFSET_MODIFIER "i", vr->request.content_length);
scgi_env_add(buf, envdup, CONST_STR_LEN("CONTENT_LENGTH"), GSTR_LEN(tmp));
}

2
src/modules/mod_throttle.c

@ -39,7 +39,7 @@ static gboolean sanity_check(liServer *srv, guint64 rate, guint64 burst) {
return FALSE;
}
if (burst < (rate * THROTTLE_GRANULARITY) / 1000) {
if (burst < (rate * LI_THROTTLE_GRANULARITY) / 1000) {
ERROR(srv, "%s", "throttle: burst is too small for the specified rate");
return FALSE;
}

6
src/unittests/test-range-parser.c

@ -39,11 +39,11 @@ static void test_range(GString *range, goffset limit, const rangeentry *results)
if (res != LI_PARSE_HTTP_RANGE_OK) break;
if (s.range_length != s.range_end - s.range_start + 1) {
range_error("unexpected range length %"L_GOFFSET_FORMAT" (expected %"L_GOFFSET_FORMAT")", s.range_length, s.range_end - s.range_start + 1);
range_error("unexpected range length %"LI_GOFFSET_FORMAT" (expected %"LI_GOFFSET_FORMAT")", s.range_length, s.range_end - s.range_start + 1);
} else if (s.range_start != results->start) {
range_error("unexpected range start %"L_GOFFSET_FORMAT" (expected %"L_GOFFSET_FORMAT")", s.range_start, results->start);
range_error("unexpected range start %"LI_GOFFSET_FORMAT" (expected %"LI_GOFFSET_FORMAT")", s.range_start, results->start);
} else if (s.range_end != results->end) {
range_error("unexpected range end %"L_GOFFSET_FORMAT" (expected %"L_GOFFSET_FORMAT")", s.range_end, results->end);
range_error("unexpected range end %"LI_GOFFSET_FORMAT" (expected %"LI_GOFFSET_FORMAT")", s.range_end, results->end);
}
}

Loading…
Cancel
Save