[Groonga-commit] groonga/groonga at 56611bd [master] Use GRN_FMT_SIZE instead of "%zu" for portability

Back to archive index

Kouhei Sutou null+****@clear*****
Sun Nov 15 14:28:15 JST 2015


Kouhei Sutou	2015-11-15 14:28:15 +0900 (Sun, 15 Nov 2015)

  New Revision: 56611bd9d97d85e74871fe6c8f8c912d7f3f0cc1
  https://github.com/groonga/groonga/commit/56611bd9d97d85e74871fe6c8f8c912d7f3f0cc1

  Message:
    Use GRN_FMT_SIZE instead of "%zu" for portability

  Modified files:
    lib/ts.c
    lib/ts/ts_buf.c
    lib/ts/ts_expr.c
    lib/ts/ts_expr_node.c
    lib/ts/ts_expr_parser.c

  Modified: lib/ts.c (+10 -5)
===================================================================
--- lib/ts.c    2015-11-15 14:20:32 +0900 (b5ccf6c)
+++ lib/ts.c    2015-11-15 14:28:15 +0900 (4a3c6f2)
@@ -413,12 +413,14 @@ grn_ts_writer_build(grn_ctx *ctx, grn_ts_writer *writer, grn_obj *table)
   }
   writer->names = GRN_MALLOCN(grn_ts_str, n_names);
   if (!writer->names) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                       sizeof(grn_ts_str), n_names);
   }
   writer->exprs = GRN_MALLOCN(grn_ts_expr *, n_names);
   if (!writer->exprs) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                       sizeof(grn_ts_expr *), n_names);
   }
   for (i = 0; i < n_names; i++) {
@@ -447,7 +449,8 @@ grn_ts_writer_open(grn_ctx *ctx, grn_obj *table, grn_ts_str str,
   grn_rc rc;
   grn_ts_writer *new_writer = GRN_MALLOCN(grn_ts_writer, 1);
   if (!new_writer) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_writer));
   }
   grn_ts_writer_init(ctx, new_writer);
@@ -563,7 +566,8 @@ grn_ts_writer_output_body(grn_ctx *ctx, grn_ts_writer *writer,
   size_t i, j, count = 0;
   writer->bufs = GRN_MALLOCN(grn_ts_buf, writer->n_exprs);
   if (!writer->bufs) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                       sizeof(grn_ts_buf), writer->n_exprs);
   }
   for (i = 0; i < writer->n_exprs; i++) {
@@ -676,7 +680,8 @@ grn_ts_select_filter(grn_ctx *ctx, grn_obj *table, grn_ts_str str,
         grn_ts_record *new_buf = (grn_ts_record *)GRN_REALLOC(buf, n_bytes);
         if (!new_buf) {
           GRN_TS_ERR(GRN_NO_MEMORY_AVAILABLE,
-                     "GRN_REALLOC failed: %zu", n_bytes);
+                     "GRN_REALLOC failed: %" GRN_FMT_SIZE,
+                     n_bytes);
           rc = ctx->rc;
           break;
         }

  Modified: lib/ts/ts_buf.c (+6 -3)
===================================================================
--- lib/ts/ts_buf.c    2015-11-15 14:20:32 +0900 (30b8aff)
+++ lib/ts/ts_buf.c    2015-11-15 14:28:15 +0900 (332196c)
@@ -36,7 +36,8 @@ grn_ts_buf_open(grn_ctx *ctx, grn_ts_buf **buf)
 {
   grn_ts_buf *new_buf = GRN_MALLOCN(grn_ts_buf, 1);
   if (!new_buf) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_buf));
   }
   grn_ts_buf_init(ctx, new_buf);
@@ -77,7 +78,8 @@ grn_ts_buf_reserve(grn_ctx *ctx, grn_ts_buf *buf, size_t new_size)
   }
   new_ptr = GRN_REALLOC(buf->ptr, enough_size);
   if (!new_ptr) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_REALLOC failed: %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_REALLOC failed: %" GRN_FMT_SIZE,
                       enough_size);
   }
   buf->ptr = new_ptr;
@@ -102,7 +104,8 @@ grn_ts_buf_resize(grn_ctx *ctx, grn_ts_buf *buf, size_t new_size)
   }
   new_ptr = GRN_REALLOC(buf->ptr, new_size);
   if (!new_ptr) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_REALLOC failed: %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_REALLOC failed: %" GRN_FMT_SIZE,
                       new_size);
   }
   buf->ptr = new_ptr;

  Modified: lib/ts/ts_expr.c (+14 -7)
===================================================================
--- lib/ts/ts_expr.c    2015-11-15 14:20:32 +0900 (ac0c399)
+++ lib/ts/ts_expr.c    2015-11-15 14:28:15 +0900 (e987c40)
@@ -112,7 +112,8 @@ grn_ts_expr_open(grn_ctx *ctx, grn_obj *table, grn_ts_expr **expr)
   }
   new_expr = GRN_MALLOCN(grn_ts_expr, 1);
   if (!new_expr) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE,
                       sizeof(grn_ts_expr));
   }
   rc = grn_ts_obj_increment_ref_count(ctx, table);
@@ -217,7 +218,8 @@ grn_ts_expr_reserve_stack(grn_ctx *ctx, grn_ts_expr *expr)
   n_bytes = sizeof(grn_ts_expr_node *) * new_size;
   new_stack = GRN_REALLOC(expr->stack, n_bytes);
   if (!new_stack) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_REALLOC failed: %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_REALLOC failed: %" GRN_FMT_SIZE,
                       n_bytes);
   }
   for (i = expr->stack_size; i < new_size; i++) {
@@ -379,7 +381,7 @@ grn_ts_expr_push_bulk(grn_ctx *ctx, grn_ts_expr *expr, grn_obj *obj)
     buf = GRN_MALLOCN(grn_ts_ ## kind, value.size);\
     if (!buf) {\
       GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,\
-                        "GRN_MALLOCN failed: %zu x 1",\
+                        "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",\
                         sizeof(grn_ts_ ## kind));\
     }\
     for (i = 0; i < value.size; i++) {\
@@ -434,7 +436,8 @@ grn_ts_expr_push_vector(grn_ctx *ctx, grn_ts_expr *expr, grn_obj *obj)
       buf = GRN_MALLOCN(grn_ts_text, value.size);
       if (!buf) {
         GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
-                          "GRN_MALLOCN failed: %zu x %zu",
+                          "GRN_MALLOCN failed: "
+                          "%" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                           sizeof(grn_ts_text), value.size);
       }
       for (i = 0; i < value.size; i++) {
@@ -687,14 +690,17 @@ grn_ts_expr_push_op(grn_ctx *ctx, grn_ts_expr *expr, grn_ts_op_type op_type)
   }
   n_args = grn_ts_op_get_n_args(op_type);
   if (!n_args) {
-    GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid #arguments: %zu", n_args);
+    GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT,
+                      "invalid #arguments: %" GRN_FMT_SIZE,
+                      n_args);
   }
   max_n_args = expr->stack_depth;
   if (expr->n_bridges) {
     max_n_args -= expr->bridges[expr->n_bridges - 1].stack_depth;
   }
   if (n_args > max_n_args) {
-    GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT, "invalid #arguments: %zu, %zu",
+    GRN_TS_ERR_RETURN(GRN_INVALID_ARGUMENT,
+                      "invalid #arguments: %" GRN_FMT_SIZE ", %" GRN_FMT_SIZE,
                       n_args, expr->stack_depth);
   }
   /* Arguments are the top n_args nodes in the stack. */
@@ -857,7 +863,8 @@ grn_ts_expr_reserve_bridges(grn_ctx *ctx, grn_ts_expr *expr)
   n_bytes = sizeof(grn_ts_expr_bridge) * new_max_n_bridges;
   new_bridges = (grn_ts_expr_bridge *)GRN_REALLOC(expr->bridges, n_bytes);
   if (!new_bridges) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_REALLOC failed: %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_REALLOC failed: %" GRN_FMT_SIZE,
                       n_bytes);
   }
   expr->bridges = new_bridges;

  Modified: lib/ts/ts_expr_node.c (+16 -8)
===================================================================
--- lib/ts/ts_expr_node.c    2015-11-15 14:20:32 +0900 (ad17bc2)
+++ lib/ts/ts_expr_node.c    2015-11-15 14:28:15 +0900 (4ae5d00)
@@ -1440,7 +1440,8 @@ grn_ts_expr_id_node_open(grn_ctx *ctx, grn_ts_expr_node **node)
 {
   grn_ts_expr_id_node *new_node = GRN_MALLOCN(grn_ts_expr_id_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_id_node));
   }
   grn_ts_expr_id_node_init(ctx, new_node);
@@ -1499,7 +1500,8 @@ grn_ts_expr_score_node_open(grn_ctx *ctx, grn_ts_expr_node **node)
 {
   grn_ts_expr_score_node *new_node = GRN_MALLOCN(grn_ts_expr_score_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_score_node));
   }
   grn_ts_expr_score_node_init(ctx, new_node);
@@ -1579,7 +1581,8 @@ grn_ts_expr_key_node_open(grn_ctx *ctx, grn_obj *table,
   }
   new_node = GRN_MALLOCN(grn_ts_expr_key_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_key_node));
   }
   grn_ts_expr_key_node_init(ctx, new_node);
@@ -1871,7 +1874,8 @@ grn_ts_expr_value_node_open(grn_ctx *ctx, grn_obj *table,
   }
   new_node = GRN_MALLOCN(grn_ts_expr_value_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_value_node));
   }
   grn_ts_expr_value_node_init(ctx, new_node);
@@ -2178,7 +2182,8 @@ grn_ts_expr_const_node_open(grn_ctx *ctx, grn_ts_data_kind kind,
   }
   grn_ts_expr_const_node *new_node = GRN_MALLOCN(grn_ts_expr_const_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_const_node));
   }
   grn_ts_expr_const_node_init(ctx, new_node);
@@ -2325,7 +2330,8 @@ grn_ts_expr_column_node_open(grn_ctx *ctx, grn_obj *column,
   grn_rc rc;
   grn_ts_expr_column_node *new_node = GRN_MALLOCN(grn_ts_expr_column_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_column_node));
   }
   grn_ts_expr_column_node_init(ctx, new_node);
@@ -3102,7 +3108,8 @@ grn_ts_expr_op_node_open(grn_ctx *ctx, grn_ts_op_type op_type,
     for (i = 0; i < n_args; i++) {
       grn_ts_expr_node_close(ctx, args[i]);
     }
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_op_node));
   }
   grn_ts_expr_op_node_init(ctx, new_node);
@@ -4524,7 +4531,8 @@ grn_ts_expr_bridge_node_open(grn_ctx *ctx, grn_ts_expr_node *src,
 {
   grn_ts_expr_bridge_node *new_node = GRN_MALLOCN(grn_ts_expr_bridge_node, 1);
   if (!new_node) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_bridge_node));
   }
   grn_ts_expr_bridge_node_init(ctx, new_node);

  Modified: lib/ts/ts_expr_parser.c (+14 -7)
===================================================================
--- lib/ts/ts_expr_parser.c    2015-11-15 14:20:32 +0900 (e083735)
+++ lib/ts/ts_expr_parser.c    2015-11-15 14:28:15 +0900 (5e83335)
@@ -217,7 +217,8 @@ grn_ts_expr_bracket_token_fin(grn_ctx *ctx, grn_ts_expr_bracket_token *token)
   grn_ts_expr_ ## type ## _token *new_token;\
   new_token = GRN_MALLOCN(grn_ts_expr_ ## type ## _token, 1);\
   if (!new_token) {\
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",\
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,\
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",\
                       sizeof(grn_ts_expr_ ## type ## _token));\
   }\
   grn_ts_expr_ ## type ## _token_init(ctx, new_token, src);\
@@ -366,7 +367,8 @@ grn_ts_expr_parser_open(grn_ctx *ctx, grn_ts_expr *expr,
 {
   grn_ts_expr_parser *new_parser = GRN_MALLOCN(grn_ts_expr_parser, 1);
   if (!new_parser) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x 1",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x 1",
                       sizeof(grn_ts_expr_parser));
   }
   grn_ts_expr_parser_init(ctx, expr, new_parser);
@@ -829,7 +831,8 @@ grn_ts_expr_parser_reserve_tokens(grn_ctx *ctx, grn_ts_expr_parser *parser)
   n_bytes = sizeof(grn_ts_expr_token *) * new_max_n_tokens;
   new_tokens = (grn_ts_expr_token **)GRN_REALLOC(parser->tokens, n_bytes);
   if (!new_tokens) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_REALLOC failed: %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_REALLOC failed: %" GRN_FMT_SIZE,
                       n_bytes);
   }
   for (i = parser->n_tokens; i < new_max_n_tokens; i++) {
@@ -979,7 +982,8 @@ grn_ts_expr_parser_apply_one(grn_ctx *ctx, grn_ts_expr_parser *parser,
     }
     default: {
       GRN_TS_ERR_RETURN(GRN_OPERATION_NOT_SUPPORTED,
-                        "invalid #arguments: %zu", n_args);
+                        "invalid #arguments: %" GRN_FMT_SIZE,
+                        n_args);
     }
   }
 
@@ -1179,12 +1183,14 @@ grn_ts_expr_parser_analyze(grn_ctx *ctx, grn_ts_expr_parser *parser)
   parser->dummy_tokens = GRN_MALLOCN(grn_ts_expr_dummy_token,
                                      parser->n_tokens);
   if (!parser->dummy_tokens) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                       sizeof(grn_ts_expr_dummy_token), parser->n_tokens);
   }
   parser->stack = GRN_MALLOCN(grn_ts_expr_token *, parser->n_tokens);
   if (!parser->stack) {
-    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE, "GRN_MALLOCN failed: %zu x %zu",
+    GRN_TS_ERR_RETURN(GRN_NO_MEMORY_AVAILABLE,
+                      "GRN_MALLOCN failed: %" GRN_FMT_SIZE " x %" GRN_FMT_SIZE,
                       sizeof(grn_ts_expr_token *), parser->n_tokens);
   }
 
@@ -1197,7 +1203,8 @@ grn_ts_expr_parser_analyze(grn_ctx *ctx, grn_ts_expr_parser *parser)
     }
   }
   if (parser->stack_depth != 2) {
-    GRN_TS_ERR_RETURN(GRN_INVALID_FORMAT, "tokens left in stack: %zu",
+    GRN_TS_ERR_RETURN(GRN_INVALID_FORMAT,
+                      "tokens left in stack: %" GRN_FMT_SIZE,
                       parser->stack_depth);
   }
   return GRN_SUCCESS;
-------------- next part --------------
HTML����������������������������...
Download 



More information about the Groonga-commit mailing list
Back to archive index