[PATCH v2 4/8] lua: rework luaL_field types to support msgpack extensions

Serge Petrenko sergepetrenko at tarantool.org
Thu Aug 8 14:55:55 MSK 2019


We are planning to add new types, such as decimal, which will all
share a single msgpack type - MP_EXT. MP_EXT is currently treated as
uninterpretable in encoders. So, in order to distinguish such new types
introduce MP_FIELD_* instead of MP_* types for use in luaL_field
structure and msgpack encoders.
New MP_FIELD_* types will correspond to MP_* types, MP_FIELD_UNKNOWN
will serve the same purpose, as MP_EXT does now, and various MP_FIELD_*
types will correspond to various MP_EXT subtypes, such as MP_DECIMAL in
future.

Prerequisite #4333
---
 src/box/lua/call.c                | 16 +++---
 src/box/lua/execute.c             | 24 ++++----
 src/box/lua/tuple.c               | 12 ++--
 src/lib/core/mp_user_types.h      | 87 +++++++++++++++++++++++++++++
 src/lua/msgpack.c                 | 93 ++++++++++++++++---------------
 src/lua/msgpack.h                 |  6 +-
 src/lua/pickle.c                  | 14 ++---
 src/lua/utils.c                   | 66 +++++++++++-----------
 src/lua/utils.h                   |  5 +-
 third_party/lua-cjson/lua_cjson.c | 28 +++++-----
 third_party/lua-yaml/lyaml.cc     | 22 ++++----
 11 files changed, 231 insertions(+), 142 deletions(-)
 create mode 100644 src/lib/core/mp_user_types.h

diff --git a/src/box/lua/call.c b/src/box/lua/call.c
index 0ac2eb7a6..189da0d1b 100644
--- a/src/box/lua/call.c
+++ b/src/box/lua/call.c
@@ -178,11 +178,11 @@ luamp_encode_call_16(lua_State *L, struct luaL_serializer *cfg,
 			if (luaL_tofield(L, cfg, i, &field) < 0)
 				return luaT_error(L);
 			struct tuple *tuple;
-			if (field.type == MP_EXT &&
+			if (field.type == MP_FIELD_UNKNOWN &&
 			    (tuple = luaT_istuple(L, i)) != NULL) {
 				/* `return ..., box.tuple.new(...), ...` */
 				tuple_to_mpstream(tuple, stream);
-			} else if (field.type != MP_ARRAY) {
+			} else if (field.type != MP_FIELD_ARRAY) {
 				/*
 				 * `return ..., scalar, ... =>
 				 *         ..., { scalar }, ...`
@@ -207,11 +207,11 @@ luamp_encode_call_16(lua_State *L, struct luaL_serializer *cfg,
 	if (luaL_tofield(L, cfg, 1, &root) < 0)
 		return luaT_error(L);
 	struct tuple *tuple;
-	if (root.type == MP_EXT && (tuple = luaT_istuple(L, 1)) != NULL) {
+	if (root.type == MP_FIELD_UNKNOWN && (tuple = luaT_istuple(L, 1)) != NULL) {
 		/* `return box.tuple()` */
 		tuple_to_mpstream(tuple, stream);
 		return 1;
-	} else if (root.type != MP_ARRAY) {
+	} else if (root.type != MP_FIELD_ARRAY) {
 		/*
 		 * `return scalar`
 		 * `return map`
@@ -222,7 +222,7 @@ luamp_encode_call_16(lua_State *L, struct luaL_serializer *cfg,
 		return 1;
 	}
 
-	assert(root.type == MP_ARRAY);
+	assert(root.type == MP_FIELD_ARRAY);
 	if (root.size == 0) {
 		/* `return {}` => `{ box.tuple() }` */
 		mpstream_encode_array(stream, 0);
@@ -230,15 +230,15 @@ luamp_encode_call_16(lua_State *L, struct luaL_serializer *cfg,
 	}
 
 	/* `return { tuple, scalar, tuple }` */
-	assert(root.type == MP_ARRAY && root.size > 0);
+	assert(root.type == MP_FIELD_ARRAY && root.size > 0);
 	for (uint32_t t = 1; t <= root.size; t++) {
 		lua_rawgeti(L, 1, t);
 		struct luaL_field field;
 		if (luaL_tofield(L, cfg, -1, &field) < 0)
 			return luaT_error(L);
-		if (field.type == MP_EXT && (tuple = luaT_istuple(L, -1))) {
+		if (field.type == MP_FIELD_UNKNOWN && (tuple = luaT_istuple(L, -1))) {
 			tuple_to_mpstream(tuple, stream);
-		} else if (field.type != MP_ARRAY) {
+		} else if (field.type != MP_FIELD_ARRAY) {
 			/* The first member of root table is not tuple/array */
 			if (t == 1) {
 				/*
diff --git a/src/box/lua/execute.c b/src/box/lua/execute.c
index 76ecdd541..fa234f6d2 100644
--- a/src/box/lua/execute.c
+++ b/src/box/lua/execute.c
@@ -141,15 +141,15 @@ lua_sql_bind_decode(struct lua_State *L, struct sql_bind *bind, int idx, int i)
 	if (luaL_tofield(L, luaL_msgpack_default, -1, &field) < 0)
 		return -1;
 	switch (field.type) {
-	case MP_UINT:
+	case MP_FIELD_UINT:
 		bind->u64 = field.ival;
 		bind->bytes = sizeof(bind->u64);
 		break;
-	case MP_INT:
+	case MP_FIELD_INT:
 		bind->i64 = field.ival;
 		bind->bytes = sizeof(bind->i64);
 		break;
-	case MP_STR:
+	case MP_FIELD_STR:
 		/*
 		 * Data should be saved in allocated memory as it
 		 * will be poped from Lua stack.
@@ -164,38 +164,38 @@ lua_sql_bind_decode(struct lua_State *L, struct sql_bind *bind, int idx, int i)
 		bind->s = buf;
 		bind->bytes = field.sval.len;
 		break;
-	case MP_DOUBLE:
-	case MP_FLOAT:
+	case MP_FIELD_DOUBLE:
+	case MP_FIELD_FLOAT:
 		bind->d = field.dval;
 		bind->bytes = sizeof(bind->d);
 		break;
-	case MP_NIL:
+	case MP_FIELD_NIL:
 		bind->bytes = 1;
 		break;
-	case MP_BOOL:
+	case MP_FIELD_BOOL:
 		/* SQLite doesn't support boolean. Use int instead. */
 		bind->i64 = field.bval ? 1 : 0;
 		bind->bytes = sizeof(bind->i64);
 		break;
-	case MP_BIN:
+	case MP_FIELD_BIN:
 		bind->s = mp_decode_bin(&field.sval.data, &bind->bytes);
 		break;
-	case MP_EXT:
+	case MP_FIELD_UNKNOWN:
 		diag_set(ClientError, ER_SQL_BIND_TYPE, "USERDATA",
 			 sql_bind_name(bind));
 		return -1;
-	case MP_ARRAY:
+	case MP_FIELD_ARRAY:
 		diag_set(ClientError, ER_SQL_BIND_TYPE, "ARRAY",
 			 sql_bind_name(bind));
 		return -1;
-	case MP_MAP:
+	case MP_FIELD_MAP:
 		diag_set(ClientError, ER_SQL_BIND_TYPE, "MAP",
 			 sql_bind_name(bind));
 		return -1;
 	default:
 		unreachable();
 	}
-	bind->type = field.type;
+	bind->type = field_type_to_msgpack(field.type);
 	lua_pop(L, lua_gettop(L) - idx);
 	return 0;
 }
diff --git a/src/box/lua/tuple.c b/src/box/lua/tuple.c
index 183c3901d..23bc73208 100644
--- a/src/box/lua/tuple.c
+++ b/src/box/lua/tuple.c
@@ -249,11 +249,11 @@ luamp_convert_key(struct lua_State *L, struct luaL_serializer *cfg,
 	struct luaL_field field;
 	if (luaL_tofield(L, cfg, index, &field) < 0)
 		luaT_error(L);
-	if (field.type == MP_ARRAY) {
+	if (field.type == MP_FIELD_ARRAY) {
 		lua_pushvalue(L, index);
 		luamp_encode_r(L, cfg, stream, &field, 0);
 		lua_pop(L, 1);
-	} else if (field.type == MP_NIL) {
+	} else if (field.type == MP_FIELD_NIL) {
 		mpstream_encode_array(stream, 0);
 	} else {
 		mpstream_encode_array(stream, 1);
@@ -270,7 +270,7 @@ luamp_encode_tuple(struct lua_State *L, struct luaL_serializer *cfg,
 	struct tuple *tuple = luaT_istuple(L, index);
 	if (tuple != NULL) {
 		return tuple_to_mpstream(tuple, stream);
-	} else if (luamp_encode(L, cfg, stream, index) != MP_ARRAY) {
+	} else if (luamp_encode(L, cfg, stream, index) != MP_FIELD_ARRAY) {
 		diag_set(ClientError, ER_TUPLE_NOT_ARRAY);
 		luaT_error(L);
 	}
@@ -286,17 +286,17 @@ tuple_to_mpstream(struct tuple *tuple, struct mpstream *stream)
 }
 
 /* A MsgPack extensions handler that supports tuples */
-static enum mp_type
+static enum mp_field_type
 luamp_encode_extension_box(struct lua_State *L, int idx,
 			   struct mpstream *stream)
 {
 	struct tuple *tuple = luaT_istuple(L, idx);
 	if (tuple != NULL) {
 		tuple_to_mpstream(tuple, stream);
-		return MP_ARRAY;
+		return MP_FIELD_ARRAY;
 	}
 
-	return MP_EXT;
+	return MP_FIELD_UNKNOWN;
 }
 
 /**
diff --git a/src/lib/core/mp_user_types.h b/src/lib/core/mp_user_types.h
new file mode 100644
index 000000000..d84748b71
--- /dev/null
+++ b/src/lib/core/mp_user_types.h
@@ -0,0 +1,87 @@
+#ifndef TARANTOOL_LIB_CORE_MP_USER_TYPES_H_INCLUDED
+#define TARANTOOL_LIB_CORE_MP_USER_TYPES_H_INCLUDED
+/*
+ * Copyright 2019, Tarantool AUTHORS, please see AUTHORS file.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+enum mp_field_type {
+	MP_FIELD_UNKNOWN,
+	MP_FIELD_NIL,
+	MP_FIELD_INT,
+	MP_FIELD_UINT,
+	MP_FIELD_STR,
+	MP_FIELD_BIN,
+	MP_FIELD_ARRAY,
+	MP_FIELD_MAP,
+	MP_FIELD_BOOL,
+	MP_FIELD_FLOAT,
+	MP_FIELD_DOUBLE,
+};
+
+static inline enum mp_type
+field_type_to_msgpack(enum mp_field_type type)
+{
+	switch (type) {
+	case MP_FIELD_NIL: return MP_NIL;
+	case MP_FIELD_INT: return MP_INT;
+	case MP_FIELD_UINT: return MP_UINT;
+	case MP_FIELD_STR: return MP_STR;
+	case MP_FIELD_BIN: return MP_BIN;
+	case MP_FIELD_ARRAY: return MP_ARRAY;
+	case MP_FIELD_MAP: return MP_MAP;
+	case MP_FIELD_BOOL: return MP_BOOL;
+	case MP_FIELD_FLOAT: return MP_FLOAT;
+	case MP_FIELD_DOUBLE: return MP_DOUBLE;
+	default: return MP_EXT;
+	}
+}
+
+static inline enum mp_field_type
+msgpack_to_field_type(const char *data)
+{
+	switch(mp_typeof(*data))
+	{
+	case MP_NIL: return MP_FIELD_NIL;
+	case MP_UINT: return MP_FIELD_UINT;
+	case MP_INT: return MP_FIELD_INT;
+	case MP_STR: return MP_FIELD_STR;
+	case MP_BIN: return MP_FIELD_BIN;
+	case MP_ARRAY: return MP_FIELD_ARRAY;
+	case MP_MAP: return MP_FIELD_MAP;
+	case MP_BOOL: return MP_FIELD_BOOL;
+	case MP_FLOAT: return MP_FIELD_FLOAT;
+	case MP_DOUBLE: return MP_FIELD_DOUBLE;
+	case MP_EXT:
+	default:
+		return MP_FIELD_UNKNOWN;
+	}
+}
+
+#endif
diff --git a/src/lua/msgpack.c b/src/lua/msgpack.c
index 2126988eb..6fc2b8278 100644
--- a/src/lua/msgpack.c
+++ b/src/lua/msgpack.c
@@ -52,7 +52,7 @@ luamp_error(void *error_ctx)
 
 struct luaL_serializer *luaL_msgpack_default = NULL;
 
-static enum mp_type
+static enum mp_field_type
 luamp_encode_extension_default(struct lua_State *L, int idx,
 			       struct mpstream *stream);
 
@@ -64,14 +64,14 @@ static luamp_encode_extension_f luamp_encode_extension =
 static luamp_decode_extension_f luamp_decode_extension =
 		luamp_decode_extension_default;
 
-static enum mp_type
+static enum mp_field_type
 luamp_encode_extension_default(struct lua_State *L, int idx,
 			       struct mpstream *stream)
 {
 	(void) L;
 	(void) idx;
 	(void) stream;
-	return MP_EXT;
+	return MP_FIELD_UNKNOWN;
 }
 
 void
@@ -102,45 +102,45 @@ luamp_set_decode_extension(luamp_decode_extension_f handler)
 	}
 }
 
-enum mp_type
+enum mp_field_type
 luamp_encode_r(struct lua_State *L, struct luaL_serializer *cfg,
 	       struct mpstream *stream, struct luaL_field *field,
 	       int level)
 {
 	int top = lua_gettop(L);
-	enum mp_type type;
+	enum mp_field_type type;
 
-restart: /* used by MP_EXT */
+restart: /* used by MP_FIELD_UNKNOWN */
 	switch (field->type) {
-	case MP_UINT:
+	case MP_FIELD_UINT:
 		mpstream_encode_uint(stream, field->ival);
-		return MP_UINT;
-	case MP_STR:
+		return MP_FIELD_UINT;
+	case MP_FIELD_STR:
 		mpstream_encode_strn(stream, field->sval.data, field->sval.len);
-		return MP_STR;
-	case MP_BIN:
+		return MP_FIELD_STR;
+	case MP_FIELD_BIN:
 		mpstream_encode_strn(stream, field->sval.data, field->sval.len);
-		return MP_BIN;
-	case MP_INT:
+		return MP_FIELD_BIN;
+	case MP_FIELD_INT:
 		mpstream_encode_int(stream, field->ival);
-		return MP_INT;
-	case MP_FLOAT:
+		return MP_FIELD_INT;
+	case MP_FIELD_FLOAT:
 		mpstream_encode_float(stream, field->fval);
-		return MP_FLOAT;
-	case MP_DOUBLE:
+		return MP_FIELD_FLOAT;
+	case MP_FIELD_DOUBLE:
 		mpstream_encode_double(stream, field->dval);
-		return MP_DOUBLE;
-	case MP_BOOL:
+		return MP_FIELD_DOUBLE;
+	case MP_FIELD_BOOL:
 		mpstream_encode_bool(stream, field->bval);
-		return MP_BOOL;
-	case MP_NIL:
+		return MP_FIELD_BOOL;
+	case MP_FIELD_NIL:
 		mpstream_encode_nil(stream);
-		return MP_NIL;
-	case MP_MAP:
+		return MP_FIELD_NIL;
+	case MP_FIELD_MAP:
 		/* Map */
 		if (level >= cfg->encode_max_depth) {
 			mpstream_encode_nil(stream); /* Limit nested maps */
-			return MP_NIL;
+			return MP_FIELD_NIL;
 		}
 		mpstream_encode_map(stream, field->size);
 		lua_pushnil(L);  /* first key */
@@ -156,12 +156,12 @@ restart: /* used by MP_EXT */
 			lua_pop(L, 1); /* pop value */
 		}
 		assert(lua_gettop(L) == top);
-		return MP_MAP;
-	case MP_ARRAY:
+		return MP_FIELD_MAP;
+	case MP_FIELD_ARRAY:
 		/* Array */
 		if (level >= cfg->encode_max_depth) {
 			mpstream_encode_nil(stream); /* Limit nested arrays */
-			return MP_NIL;
+			return MP_FIELD_NIL;
 		}
 		uint32_t size = field->size;
 		mpstream_encode_array(stream, size);
@@ -173,23 +173,23 @@ restart: /* used by MP_EXT */
 			lua_pop(L, 1);
 		}
 		assert(lua_gettop(L) == top);
-		return MP_ARRAY;
-	case MP_EXT:
+		return MP_FIELD_ARRAY;
+	case MP_FIELD_UNKNOWN:
 		/* Run trigger if type can't be encoded */
 		type = luamp_encode_extension(L, top, stream);
-		if (type != MP_EXT)
+		if (type != MP_FIELD_UNKNOWN)
 			return type; /* Value has been packed by the trigger */
 		/* Try to convert value to serializable type */
 		luaL_convertfield(L, cfg, top, field);
 		/* handled by luaL_convertfield */
-		assert(field->type != MP_EXT);
+		assert(field->type != MP_FIELD_UNKNOWN);
 		assert(lua_gettop(L) == top);
 		goto restart;
 	}
-	return MP_EXT;
+	return MP_FIELD_UNKNOWN;
 }
 
-enum mp_type
+enum mp_field_type
 luamp_encode(struct lua_State *L, struct luaL_serializer *cfg,
 	     struct mpstream *stream, int index)
 {
@@ -205,7 +205,7 @@ luamp_encode(struct lua_State *L, struct luaL_serializer *cfg,
 	struct luaL_field field;
 	if (luaL_tofield(L, cfg, lua_gettop(L), &field) < 0)
 		return luaT_error(L);
-	enum mp_type top_type = luamp_encode_r(L, cfg, stream, &field, 0);
+	enum mp_field_type top_type = luamp_encode_r(L, cfg, stream, &field, 0);
 
 	if (!on_top) {
 		lua_remove(L, top + 1); /* remove a value copy */
@@ -219,45 +219,46 @@ luamp_decode(struct lua_State *L, struct luaL_serializer *cfg,
 	     const char **data)
 {
 	double d;
-	switch (mp_typeof(**data)) {
-	case MP_UINT:
+	enum mp_field_type type = msgpack_to_field_type(*data);
+	switch (type) {
+	case MP_FIELD_UINT:
 		luaL_pushuint64(L, mp_decode_uint(data));
 		break;
-	case MP_INT:
+	case MP_FIELD_INT:
 		luaL_pushint64(L, mp_decode_int(data));
 		break;
-	case MP_FLOAT:
+	case MP_FIELD_FLOAT:
 		d = mp_decode_float(data);
 		luaL_checkfinite(L, cfg, d);
 		lua_pushnumber(L, d);
 		return;
-	case MP_DOUBLE:
+	case MP_FIELD_DOUBLE:
 		d = mp_decode_double(data);
 		luaL_checkfinite(L, cfg, d);
 		lua_pushnumber(L, d);
 		return;
-	case MP_STR:
+	case MP_FIELD_STR:
 	{
 		uint32_t len = 0;
 		const char *str = mp_decode_str(data, &len);
 		lua_pushlstring(L, str, len);
 		return;
 	}
-	case MP_BIN:
+	case MP_FIELD_BIN:
 	{
 		uint32_t len = 0;
 		const char *str = mp_decode_bin(data, &len);
 		lua_pushlstring(L, str, len);
 		return;
 	}
-	case MP_BOOL:
+	case MP_FIELD_BOOL:
 		lua_pushboolean(L, mp_decode_bool(data));
 		return;
-	case MP_NIL:
+	case MP_FIELD_NIL:
 		mp_decode_nil(data);
 		luaL_pushnull(L);
 		return;
-	case MP_ARRAY:
+	case MP_FIELD_ARRAY:
 	{
 		uint32_t size = mp_decode_array(data);
 		lua_createtable(L, size, 0);
@@ -269,7 +270,7 @@ luamp_decode(struct lua_State *L, struct luaL_serializer *cfg,
 			luaL_setarrayhint(L, -1);
 		return;
 	}
-	case MP_MAP:
+	case MP_FIELD_MAP:
 	{
 		uint32_t size = mp_decode_map(data);
 		lua_createtable(L, 0, size);
@@ -282,7 +283,7 @@ luamp_decode(struct lua_State *L, struct luaL_serializer *cfg,
 			luaL_setmaphint(L, -1);
 		return;
 	}
-	case MP_EXT:
+	case MP_FIELD_UNKNOWN:
 		luamp_decode_extension(L, data);
 		break;
 	}
diff --git a/src/lua/msgpack.h b/src/lua/msgpack.h
index d0ade303f..08b8d5baf 100644
--- a/src/lua/msgpack.h
+++ b/src/lua/msgpack.h
@@ -61,12 +61,12 @@ luamp_error(void *);
 enum { LUAMP_ALLOC_FACTOR = 256 };
 
 /* low-level function needed for execute_lua_call() */
-enum mp_type
+enum mp_field_type
 luamp_encode_r(struct lua_State *L, struct luaL_serializer *cfg,
 	       struct mpstream *stream, struct luaL_field *field,
 	       int level);
 
-enum mp_type
+enum mp_field_type
 luamp_encode(struct lua_State *L, struct luaL_serializer *cfg,
 	     struct mpstream *stream, int index);
 
@@ -74,7 +74,7 @@ void
 luamp_decode(struct lua_State *L, struct luaL_serializer *cfg,
 	     const char **data);
 
-typedef enum mp_type
+typedef enum mp_field_type
 (*luamp_encode_extension_f)(struct lua_State *, int, struct mpstream *);
 
 /**
diff --git a/src/lua/pickle.c b/src/lua/pickle.c
index 65208b5b3..046fbba2f 100644
--- a/src/lua/pickle.c
+++ b/src/lua/pickle.c
@@ -85,7 +85,7 @@ lbox_pack(struct lua_State *L)
 		case 'B':
 		case 'b':
 			/* signed and unsigned 8-bit integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 8-bit int");
 
 			luaL_region_dup(L, buf, &field.ival, sizeof(uint8_t));
@@ -93,14 +93,14 @@ lbox_pack(struct lua_State *L)
 		case 'S':
 		case 's':
 			/* signed and unsigned 16-bit integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 16-bit int");
 
 			luaL_region_dup(L, buf, &field.ival, sizeof(uint16_t));
 			break;
 		case 'n':
 			/* signed and unsigned 16-bit big endian integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 16-bit int");
 
 			field.ival = (uint16_t) htons((uint16_t) field.ival);
@@ -109,14 +109,14 @@ lbox_pack(struct lua_State *L)
 		case 'I':
 		case 'i':
 			/* signed and unsigned 32-bit integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 32-bit int");
 
 			luaL_region_dup(L, buf, &field.ival, sizeof(uint32_t));
 			break;
 		case 'N':
 			/* signed and unsigned 32-bit big endian integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 32-bit int");
 
 			field.ival = htonl(field.ival);
@@ -125,7 +125,7 @@ lbox_pack(struct lua_State *L)
 		case 'L':
 		case 'l':
 			/* signed and unsigned 64-bit integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 64-bit int");
 
 			luaL_region_dup(L, buf, &field.ival, sizeof(uint64_t));
@@ -133,7 +133,7 @@ lbox_pack(struct lua_State *L)
 		case 'Q':
 		case 'q':
 			/* signed and unsigned 64-bit integers */
-			if (field.type != MP_UINT && field.type != MP_INT)
+			if (field.type != MP_FIELD_UINT && field.type != MP_FIELD_INT)
 				luaL_error(L, "pickle.pack: expected 64-bit int");
 
 			field.ival = bswap_u64(field.ival);
diff --git a/src/lua/utils.c b/src/lua/utils.c
index 0a4bcf517..9b2f4fd6c 100644
--- a/src/lua/utils.c
+++ b/src/lua/utils.c
@@ -501,13 +501,13 @@ lua_field_try_serialize(struct lua_State *L)
 	const char *type = lua_tostring(L, -1);
 	if (strcmp(type, "array") == 0 || strcmp(type, "seq") == 0 ||
 	    strcmp(type, "sequence") == 0) {
-		field->type = MP_ARRAY; /* Override type */
+		field->type = MP_FIELD_ARRAY; /* Override type */
 		field->size = luaL_arrlen(L, 1);
 		/* YAML: use flow mode if __serialize == 'seq' */
 		if (cfg->has_compact && type[3] == '\0')
 			field->compact = true;
 	} else if (strcmp(type, "map") == 0 || strcmp(type, "mapping") == 0) {
-		field->type = MP_MAP;   /* Override type */
+		field->type = MP_FIELD_MAP;   /* Override type */
 		field->size = luaL_maplen(L, 1);
 		/* YAML: use flow mode if __serialize == 'map' */
 		if (cfg->has_compact && type[3] == '\0')
@@ -562,7 +562,7 @@ lua_field_inspect_table(struct lua_State *L, struct luaL_serializer *cfg,
 		lua_pop(L, 1);
 	}
 
-	field->type = MP_ARRAY;
+	field->type = MP_FIELD_ARRAY;
 
 	/* Calculate size and check that table can represent an array */
 	lua_pushnil(L);
@@ -578,7 +578,7 @@ lua_field_inspect_table(struct lua_State *L, struct luaL_serializer *cfg,
 				size++;
 				lua_pop(L, 1); /* pop the value */
 			}
-			field->type = MP_MAP;
+			field->type = MP_FIELD_MAP;
 			field->size = size;
 			return 0;
 		}
@@ -594,12 +594,12 @@ lua_field_inspect_table(struct lua_State *L, struct luaL_serializer *cfg,
 			diag_set(LuajitError, "excessively sparse array");
 			return -1;
 		}
-		field->type = MP_MAP;
+		field->type = MP_FIELD_MAP;
 		field->size = size;
 		return 0;
 	}
 
-	assert(field->type == MP_ARRAY);
+	assert(field->type == MP_FIELD_ARRAY);
 	field->size = max;
 	return 0;
 }
@@ -635,23 +635,23 @@ luaL_tofield(struct lua_State *L, struct luaL_serializer *cfg, int index,
 			diag_set(LuajitError, "number must not be NaN or Inf");	\
 			return -1;						\
 		}								\
-		field->type = MP_NIL;						\
+		field->type = MP_FIELD_NIL;						\
 	}})
 
 	switch (lua_type(L, index)) {
 	case LUA_TNUMBER:
 		num = lua_tonumber(L, index);
 		if (isfinite(num) && modf(num, &intpart) != 0.0) {
-			field->type = MP_DOUBLE;
+			field->type = MP_FIELD_DOUBLE;
 			field->dval = num;
 		} else if (num >= 0 && num < exp2(64)) {
-			field->type = MP_UINT;
+			field->type = MP_FIELD_UINT;
 			field->ival = (uint64_t) num;
 		} else if (num > -exp2(63) && num < exp2(63)) {
-			field->type = MP_INT;
+			field->type = MP_FIELD_INT;
 			field->ival = (int64_t) num;
 		} else {
-			field->type = MP_DOUBLE;
+			field->type = MP_FIELD_DOUBLE;
 			field->dval = num;
 			CHECK_NUMBER(num);
 		}
@@ -664,79 +664,79 @@ luaL_tofield(struct lua_State *L, struct luaL_serializer *cfg, int index,
 		int64_t ival;
 		switch (cd->ctypeid) {
 		case CTID_BOOL:
-			field->type = MP_BOOL;
+			field->type = MP_FIELD_BOOL;
 			field->bval = *(bool*) cdata;
 			return 0;
 		case CTID_CCHAR:
 		case CTID_INT8:
 			ival = *(int8_t *) cdata;
-			field->type = (ival >= 0) ? MP_UINT : MP_INT;
+			field->type = (ival >= 0) ? MP_FIELD_UINT : MP_FIELD_INT;
 			field->ival = ival;
 			return 0;
 		case CTID_INT16:
 			ival = *(int16_t *) cdata;
-			field->type = (ival >= 0) ? MP_UINT : MP_INT;
+			field->type = (ival >= 0) ? MP_FIELD_UINT : MP_FIELD_INT;
 			field->ival = ival;
 			return 0;
 		case CTID_INT32:
 			ival = *(int32_t *) cdata;
-			field->type = (ival >= 0) ? MP_UINT : MP_INT;
+			field->type = (ival >= 0) ? MP_FIELD_UINT : MP_FIELD_INT;
 			field->ival = ival;
 			return 0;
 		case CTID_INT64:
 			ival = *(int64_t *) cdata;
-			field->type = (ival >= 0) ? MP_UINT : MP_INT;
+			field->type = (ival >= 0) ? MP_FIELD_UINT : MP_FIELD_INT;
 			field->ival = ival;
 			return 0;
 		case CTID_UINT8:
-			field->type = MP_UINT;
+			field->type = MP_FIELD_UINT;
 			field->ival = *(uint8_t *) cdata;
 			return 0;
 		case CTID_UINT16:
-			field->type = MP_UINT;
+			field->type = MP_FIELD_UINT;
 			field->ival = *(uint16_t *) cdata;
 			return 0;
 		case CTID_UINT32:
-			field->type = MP_UINT;
+			field->type = MP_FIELD_UINT;
 			field->ival = *(uint32_t *) cdata;
 			return 0;
 		case CTID_UINT64:
-			field->type = MP_UINT;
+			field->type = MP_FIELD_UINT;
 			field->ival = *(uint64_t *) cdata;
 			return 0;
 		case CTID_FLOAT:
-			field->type = MP_FLOAT;
+			field->type = MP_FIELD_FLOAT;
 			field->fval = *(float *) cdata;
 			CHECK_NUMBER(field->fval);
 			return 0;
 		case CTID_DOUBLE:
-			field->type = MP_DOUBLE;
+			field->type = MP_FIELD_DOUBLE;
 			field->dval = *(double *) cdata;
 			CHECK_NUMBER(field->dval);
 			return 0;
 		case CTID_P_CVOID:
 		case CTID_P_VOID:
 			if (*(void **) cdata == NULL) {
-				field->type = MP_NIL;
+				field->type = MP_FIELD_NIL;
 				return 0;
 			}
 			/* Fall through */
 		default:
-			field->type = MP_EXT;
+			field->type = MP_FIELD_UNKNOWN;
 		}
 		return 0;
 	}
 	case LUA_TBOOLEAN:
-		field->type = MP_BOOL;
+		field->type = MP_FIELD_BOOL;
 		field->bval = lua_toboolean(L, index);
 		return 0;
 	case LUA_TNIL:
-		field->type = MP_NIL;
+		field->type = MP_FIELD_NIL;
 		return 0;
 	case LUA_TSTRING:
 		field->sval.data = lua_tolstring(L, index, &size);
 		field->sval.len = (uint32_t) size;
-		field->type = MP_STR;
+		field->type = MP_FIELD_STR;
 		return 0;
 	case LUA_TTABLE:
 	{
@@ -748,12 +748,12 @@ luaL_tofield(struct lua_State *L, struct luaL_serializer *cfg, int index,
 		field->sval.data = NULL;
 		field->sval.len = 0;
 		if (lua_touserdata(L, index) == NULL) {
-			field->type = MP_NIL;
+			field->type = MP_FIELD_NIL;
 			return 0;
 		}
 		/* Fall through */
 	default:
-		field->type = MP_EXT;
+		field->type = MP_FIELD_UNKNOWN;
 	}
 #undef CHECK_NUMBER
 	return 0;
@@ -765,7 +765,7 @@ luaL_convertfield(struct lua_State *L, struct luaL_serializer *cfg, int idx,
 {
 	if (idx < 0)
 		idx = lua_gettop(L) + idx + 1;
-	assert(field->type == MP_EXT); /* must be called after tofield() */
+	assert(field->type == MP_FIELD_UNKNOWN); /* must be called after tofield() */
 
 	if (cfg->encode_load_metatables) {
 		int type = lua_type(L, idx);
@@ -782,14 +782,14 @@ luaL_convertfield(struct lua_State *L, struct luaL_serializer *cfg, int idx,
 		}
 	}
 
-	if (field->type == MP_EXT && cfg->encode_use_tostring)
+	if (field->type == MP_FIELD_UNKNOWN && cfg->encode_use_tostring)
 		lua_field_tostring(L, cfg, idx, field);
 
-	if (field->type != MP_EXT)
+	if (field->type != MP_FIELD_UNKNOWN)
 		return;
 
 	if (cfg->encode_invalid_as_nil) {
-		field->type = MP_NIL;
+		field->type = MP_FIELD_NIL;
 		return;
 	}
 
diff --git a/src/lua/utils.h b/src/lua/utils.h
index 7e7cdc0c6..4a314ab32 100644
--- a/src/lua/utils.h
+++ b/src/lua/utils.h
@@ -54,6 +54,7 @@ extern "C" {
 #include <lj_meta.h>
 
 #include "lua/error.h"
+#include "lib/core/mp_user_types.h"
 
 struct lua_State;
 struct ibuf;
@@ -287,7 +288,7 @@ struct luaL_field {
 		/* Array or map. */
 		uint32_t size;
 	};
-	enum mp_type type;
+	enum mp_field_type type;
 	bool compact;                /* a flag used by YAML serializer */
 };
 
@@ -373,7 +374,7 @@ luaL_checkfield(struct lua_State *L, struct luaL_serializer *cfg, int idx,
 {
 	if (luaL_tofield(L, cfg, idx, field) < 0)
 		luaT_error(L);
-	if (field->type != MP_EXT)
+	if (field->type != MP_FIELD_UNKNOWN)
 		return;
 	luaL_convertfield(L, cfg, idx, field);
 }
diff --git a/third_party/lua-cjson/lua_cjson.c b/third_party/lua-cjson/lua_cjson.c
index 631c53e3f..d8244054c 100644
--- a/third_party/lua-cjson/lua_cjson.c
+++ b/third_party/lua-cjson/lua_cjson.c
@@ -348,15 +348,15 @@ static void json_append_object(lua_State *l, struct luaL_serializer *cfg,
 
     struct luaL_field field;
     luaL_checkfield(l, cfg, -2, &field);
-    if (field.type == MP_UINT) {
+    if (field.type == MP_FIELD_UINT) {
         strbuf_append_char(json, '"');
         json_append_uint(cfg, json, field.ival);
         strbuf_append_mem(json, "\":", 2);
-    } else if (field.type == MP_INT) {
+    } else if (field.type == MP_FIELD_INT) {
         strbuf_append_char(json, '"');
         json_append_int(cfg, json, field.ival);
         strbuf_append_mem(json, "\":", 2);
-    } else if (field.type == MP_STR) {
+    } else if (field.type == MP_FIELD_STR) {
         json_append_string(cfg, json, field.sval.data, field.sval.len);
         strbuf_append_char(json, ':');
     } else {
@@ -379,38 +379,38 @@ static void json_append_data(lua_State *l, struct luaL_serializer *cfg,
     struct luaL_field field;
     luaL_checkfield(l, cfg, -1, &field);
     switch (field.type) {
-    case MP_UINT:
+    case MP_FIELD_UINT:
         return json_append_uint(cfg, json, field.ival);
-    case MP_STR:
-    case MP_BIN:
+    case MP_FIELD_STR:
+    case MP_FIELD_BIN:
         return json_append_string(cfg, json, field.sval.data, field.sval.len);
-    case MP_INT:
+    case MP_FIELD_INT:
         return json_append_int(cfg, json, field.ival);
-    case MP_FLOAT:
+    case MP_FIELD_FLOAT:
         return json_append_number(cfg, json, field.fval);
-    case MP_DOUBLE:
+    case MP_FIELD_DOUBLE:
         return json_append_number(cfg, json, field.dval);
-    case MP_BOOL:
+    case MP_FIELD_BOOL:
     if (field.bval)
         strbuf_append_mem(json, "true", 4);
     else
         strbuf_append_mem(json, "false", 5);
     break;
-    case MP_NIL:
+    case MP_FIELD_NIL:
     json_append_nil(cfg, json);
     break;
-    case MP_MAP:
+    case MP_FIELD_MAP:
     if (current_depth >= cfg->encode_max_depth)
         return json_append_nil(cfg, json); /* Limit nested maps */
     json_append_object(l, cfg, current_depth, json);
     return;
-    case MP_ARRAY:
+    case MP_FIELD_ARRAY:
     /* Array */
     if (current_depth >= cfg->encode_max_depth)
         return json_append_nil(cfg, json); /* Limit nested arrays */
     json_append_array(l, cfg, current_depth, json, field.size);
     return;
-    case MP_EXT:
+    case MP_FIELD_UNKNOWN:
     /* handled by luaL_convertfield */
     assert(false);
     return;
diff --git a/third_party/lua-yaml/lyaml.cc b/third_party/lua-yaml/lyaml.cc
index 46c98bde1..23d10335b 100644
--- a/third_party/lua-yaml/lyaml.cc
+++ b/third_party/lua-yaml/lyaml.cc
@@ -620,33 +620,33 @@ static int dump_node(struct lua_yaml_dumper *dumper)
    int top = lua_gettop(dumper->L);
    luaL_checkfield(dumper->L, dumper->cfg, top, &field);
    switch(field.type) {
-   case MP_UINT:
+   case MP_FIELD_UINT:
       snprintf(buf, sizeof(buf) - 1, "%" PRIu64, field.ival);
       buf[sizeof(buf) - 1] = 0;
       str = buf;
       len = strlen(buf);
       break;
-   case MP_INT:
+   case MP_FIELD_INT:
       snprintf(buf, sizeof(buf) - 1, "%" PRIi64, field.ival);
       buf[sizeof(buf) - 1] = 0;
       str = buf;
       len = strlen(buf);
       break;
-   case MP_FLOAT:
+   case MP_FIELD_FLOAT:
       fpconv_g_fmt(buf, field.fval, dumper->cfg->encode_number_precision);
       str = buf;
       len = strlen(buf);
       break;
-   case MP_DOUBLE:
+   case MP_FIELD_DOUBLE:
       fpconv_g_fmt(buf, field.dval, dumper->cfg->encode_number_precision);
       str = buf;
       len = strlen(buf);
       break;
-   case MP_ARRAY:
+   case MP_FIELD_ARRAY:
       return dump_array(dumper, &field);
-   case MP_MAP:
+   case MP_FIELD_MAP:
       return dump_table(dumper, &field);
-   case MP_STR:
+   case MP_FIELD_STR:
       str = lua_tolstring(dumper->L, -1, &len);
       if (yaml_is_null(str, len) || yaml_is_bool(str, len, &unused) ||
           lua_isnumber(dumper->L, -1)) {
@@ -672,13 +672,13 @@ static int dump_node(struct lua_yaml_dumper *dumper)
          break;
       }
       /* Fall through */
-   case MP_BIN:
+   case MP_FIELD_BIN:
       is_binary = 1;
       tobase64(dumper->L, -1);
       str = lua_tolstring(dumper->L, -1, &len);
       tag = (yaml_char_t *) LUAYAML_TAG_PREFIX "binary";
       break;
-   case MP_BOOL:
+   case MP_FIELD_BOOL:
       if (field.bval) {
          str = "true";
          len = 4;
@@ -687,12 +687,12 @@ static int dump_node(struct lua_yaml_dumper *dumper)
          len = 5;
       }
       break;
-   case MP_NIL:
+   case MP_FIELD_NIL:
       style = YAML_PLAIN_SCALAR_STYLE;
       str = "null";
       len = 4;
       break;
-   case MP_EXT:
+   case MP_FIELD_UNKNOWN:
       assert(0); /* checked by luaL_checkfield() */
       break;
     }
-- 
2.20.1 (Apple Git-117)




More information about the Tarantool-patches mailing list