diff --git a/libxo/libxo.c b/libxo/libxo.c index fa2ab410..43af2395 100644 --- a/libxo/libxo.c +++ b/libxo/libxo.c @@ -123,12 +123,11 @@ extern char etext; #define TRUE 1 #endif -/* - * Older versions of GCC don't have this - */ +/* Make our own version for older versions of GCC that don't have this */ #ifndef __GNUC_PREREQ -#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) -#endif +#define __GNUC_PREREQ(maj,min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#endif /* __GNUC_PREREQ */ /* * Three styles of specifying thread-local variables are supported. @@ -719,6 +718,13 @@ xo_init_handle (xo_handle_t *xop) XOIF_CLEAR(xop, XOIF_INIT_IN_PROGRESS); } +static void +xo_default_init_utf8 (xo_handle_t *xop) +{ + if (xo_codeset_is_utf8) + XOF_SET(xop, XOF_UTF8); +} + /* * Initialize the default handle. */ @@ -728,9 +734,7 @@ xo_default_init (void) xo_handle_t *xop = &xo_default_handle; xo_init_handle(xop); - - if (xo_codeset_is_utf8) - XOF_SET(xop, XOF_UTF8); + xo_default_init_utf8(xop); xo_default_inited = 1; } @@ -3475,23 +3479,15 @@ xo_trim_ws (xo_buffer_t *xbp, ssize_t len) } /* - * Safely pull a "long double" off a va_list. This is a workaround - * for a va_arg bug on PowerPC for gcc 4.9.2 and later. + * Pull a "long double" off our va_list. This was originally done as + * a function to hide some evil bits we had to do to work around a + * gcc-4.9 bug, but that's ancient so we've removed the evil but left + * the function just in case the bug returns. A pessimist, eh? */ static inline void xo_safe_va_arg_long_double (xo_handle_t *xop) { -#ifndef __GNUC_PREREQ -#if !__GNUC_PREREQ(4, 9) || !defined(PPC) va_arg(xop->xo_vap, long double); -#elif (sizeof(long double) != sizeof(uint64_t)) - #error "size check failure: (sizeof(long double) != sizeof(uint64_t))" -#else - va_arg(xop->xo_vap, uint64_t); -#endif /* __GNUC_PREREQ(4, 9) */ -#else /* __GNUC_PREREQ */ - va_arg(xop->xo_vap, uint64_t); -#endif /* __GNUC_PREREQ */ } /* diff --git a/libxo/xo_filter.c b/libxo/xo_filter.c index ad18a53a..394574bb 100644 --- a/libxo/xo_filter.c +++ b/libxo/xo_filter.c @@ -1032,6 +1032,9 @@ typedef struct xo_eval_value_s { #define XEVF_UNSUPPORTED (1<<3) /* Token type is not supported */ #define XEVF_FINAL (1<<4) /* This is the final answer */ +#define XO_EVAL_VALUE_ZERO { .xev_flags = 0 } +#define XO_EVAL_VALUE_INVALID { .xev_type = M_ERROR, .xev_flags = XEVF_INVALID } + #define XO_EVAL_OP_ARGS \ xo_handle_t *xop UNUSED, xo_filter_t *xfp UNUSED, xo_match_t *xmp UNUSED, \ xo_xparse_node_t *xnp UNUSED, \ @@ -1057,7 +1060,7 @@ typedef xo_eval_value_t (xo_eval_calc_fn_t)(XO_EVAL_CALC_ARGS); static inline xo_eval_value_t xo_eval_value_make (unsigned type, unsigned flags, xo_xparse_node_id_t id) { - xo_eval_value_t value = { 0 }; + xo_eval_value_t value = XO_EVAL_VALUE_ZERO; value.xev_type = type; value.xev_flags = flags; @@ -1071,7 +1074,7 @@ xo_eval_value_make (unsigned type, unsigned flags, xo_xparse_node_id_t id) static inline xo_eval_value_t xo_eval_value_float (unsigned flags, xo_float_t val) { - xo_eval_value_t value = { 0 }; + xo_eval_value_t value = XO_EVAL_VALUE_ZERO; value.xev_type = C_FLOAT; value.xev_flags = flags; @@ -1083,14 +1086,7 @@ xo_eval_value_float (unsigned flags, xo_float_t val) static inline xo_eval_value_t xo_eval_value_invalid (void) { - xo_eval_value_t value = { 0 }; - - value.xev_type = M_ERROR; - value.xev_flags = XEVF_INVALID; - value.xev_pad = 0; - value.xev_node = 0; - value.xev_uint64 = 0; - + xo_eval_value_t value = XO_EVAL_VALUE_INVALID; return value; } @@ -1102,7 +1098,7 @@ xo_eval (xo_handle_t *xop, xo_filter_t *xfp, xo_match_t *xmp, static xo_eval_value_t xo_eval_number (XO_EVAL_NODE_ARGS) { - xo_eval_value_t value = { .xev_flags = 0 }; + xo_eval_value_t value = XO_EVAL_VALUE_ZERO; const char *str = xo_xparse_str(&xfp->xf_xd, xnp->xn_str); char *ep; int64_t ival = strtoll(str, &ep, 0); @@ -1293,7 +1289,7 @@ xo_eval_dump_value (xo_handle_t *xop UNUSED, xo_filter_t *xfp UNUSED, static xo_eval_value_t xo_eval_compare (XO_EVAL_OP_ARGS) { - xo_eval_value_t value = { 0 }; + xo_eval_value_t value = XO_EVAL_VALUE_ZERO; int rc = 0; xo_float_t fval; @@ -1555,8 +1551,8 @@ xo_eval (xo_handle_t *xop, xo_filter_t *xfp, xo_match_t *xmp, xo_xparse_node_id_t id, xo_eval_op_fn_t op_fn) { xo_eval_value_t value = xo_eval_value_invalid(); + xo_eval_value_t last = XO_EVAL_VALUE_ZERO; int first = 1; - xo_eval_value_t last = { 0 }; xo_xparse_dump_one_node(&xfp->xf_xd, id, 0, "eval one: "); @@ -1699,7 +1695,7 @@ xo_eval (xo_handle_t *xop, xo_filter_t *xfp, xo_match_t *xmp, static xo_eval_value_t xo_filter_pred_eval (xo_handle_t *xop, xo_filter_t *xfp, xo_match_t *xmp) { - xo_eval_value_t value = { 0 }; + xo_eval_value_t value = XO_EVAL_VALUE_ZERO; xo_xparse_dump_one_node(&xfp->xf_xd, xmp->xm_stackp->xs_predicates, 0, "eval: "); diff --git a/libxo/xo_humanize.h b/libxo/xo_humanize.h index ca41b863..b9b23859 100644 --- a/libxo/xo_humanize.h +++ b/libxo/xo_humanize.h @@ -62,17 +62,30 @@ xo_humanize_number (char *buf, size_t len, int64_t bytes, const char *suffix, int scale, int flags) { const char *prefixes, *sep; - int b, i, r, maxscale, s1, s2, sign; + int b, i, r, s1, s2, sign; int64_t divisor, max; - // We multiply bytes by 100 to deal with rounding, so we need something - // big enough to hold LLONG_MAX * 100. On 64-bit we can use 128-bit wide - // integers with __int128_t, but on 32-bit we have to use long double. + + /* + * We multiply bytes by 100 to deal with rounding, so we need + * something big enough to hold LLONG_MAX * 100. On 64-bit we + * can use 128-bit wide integers with __int128_t, but on + * 32-bit we have to use long double. + * + * Note: For mips 64 but architecture, we have missing + * undefined reference to `__divti3', which is observed when + * 128 bit wide integers with __int128_t is used, so in this + * case also we will use 32-bit and we have to use long + * double. + */ #ifdef __LP64__ - __int128_t scalable = (__int128_t)bytes; +#if defined __FreeBSD__ && __FreeBSD__ == 6 && defined __mips64__ + long double scalable = (long double)bytes; #else - long double scalable = (long double)bytes; + __int128_t scalable = (__int128_t)bytes; +#endif +#else + long double scalable = (long double)bytes; #endif - size_t baselen; assert(buf != NULL); assert(suffix != NULL); @@ -98,7 +111,8 @@ xo_humanize_number (char *buf, size_t len, int64_t bytes, } #define SCALE2PREFIX(scale) (&prefixes[(scale) << 1]) - maxscale = 7; + int maxscale = 7; + size_t baselen; if (scale >= maxscale && (scale & (HN_AUTOSCALE | HN_GETSCALE)) == 0) @@ -118,12 +132,14 @@ xo_humanize_number (char *buf, size_t len, int64_t bytes, scalable *= 100; baselen = 2; /* digit, prefix */ } + if (flags & HN_NOSPACE) sep = ""; else { sep = " "; baselen++; } + baselen += strlen(suffix); /* Check if enough room for `x y' + suffix + `\0' */ diff --git a/libxo/xo_syslog.c b/libxo/xo_syslog.c index 42223405..2c67be3c 100644 --- a/libxo/xo_syslog.c +++ b/libxo/xo_syslog.c @@ -43,7 +43,6 @@ #include #include #include -#include #include #include #include @@ -99,13 +98,13 @@ #define XO_DEFAULT_EID 32473 /* Fallback to the "example" number */ #endif -#ifndef HOST_NAME_MAX +#ifndef XO_HOST_NAME_MAX #ifdef _POSIX_HOST_NAME_MAX -#define HOST_NAME_MAX _POSIX_HOST_NAME_MAX +#define XO_HOST_NAME_MAX _POSIX_HOST_NAME_MAX #else -#define HOST_NAME_MAX 255 +#define XO_HOST_NAME_MAX 255 #endif /* _POSIX_HOST_NAME_MAX */ -#endif /* HOST_NAME_MAX */ +#endif /* XO_HOST_NAME_MAX */ static int xo_logfile = -1; /* fd for log */ static int xo_status; /* connection xo_status */ @@ -550,7 +549,7 @@ xo_vsyslog (int pri, const char *name, const char *fmt, va_list vap) } else gettimeofday(&tv, NULL); - (void) localtime_r(&tv.tv_sec, &tm); + (void) localtime_r((time_t *) &tv.tv_sec, &tm); if (xo_logstat & LOG_PERROR) { /* @@ -584,13 +583,13 @@ xo_vsyslog (int pri, const char *name, const char *fmt, va_list vap) * Add HOSTNAME; we rely on gethostname and don't fluff with * ip addresses. Might need to revisit..... */ - char hostname[HOST_NAME_MAX + 1]; + char hostname[XO_HOST_NAME_MAX + 1]; hostname[0] = '\0'; if (xo_unit_test) strcpy(hostname, "worker-host"); else (void) gethostname(hostname, sizeof(hostname) - 1); - hostname[HOST_NAME_MAX] = '\0'; /* Ensure NUL-terminated */ + hostname[XO_HOST_NAME_MAX] = '\0'; /* Ensure NUL-terminated */ xb.xb_curp += xo_snprintf(xb.xb_curp, xo_buf_left(&xb), "%s ", hostname[0] ? hostname : "-"); diff --git a/libxo/xo_xpath.y b/libxo/xo_xpath.y index a6f1930e..5394c96d 100644 --- a/libxo/xo_xpath.y +++ b/libxo/xo_xpath.y @@ -79,7 +79,7 @@ * Literal tokens which _may_ preceed the multiplication operator */ %token M_MULTIPLICATION_TEST_LAST 45 /* Magic marker: highest token number */ -%token L_ASTERISK 46 "*" +%token L_ASTERISK 46 /* "*" */ %token L_CBRACK 47 "]" %token L_CPAREN 48 ")" %token L_DOT 49 "." @@ -211,6 +211,9 @@ #define yylex(_lvalp, _param) \ xo_xpath_yylex(_param, _lvalp) +#define yytname xo_xpath_yyname +#define yypact xo_xpath_yydefred + /* * Even if we don't want debug printfs, we still need the arrays with * names for our own nefarious purposes. @@ -830,9 +833,6 @@ xp_relational_expr : #define YYLAST ((sizeof(yytable) / sizeof(yytable[0])) - 1) #endif /* YYLAST */ -#define yytname xo_xpath_yyname -#define yypact xo_xpath_yydefred - const int xo_xparse_num_tokens = YYNTOKENS; const char *xo_xparse_keyword_string[YYNTOKENS]; const char *xo_xparse_token_name_fancy[YYNTOKENS];