ft: 添加生成lua的序列化代码

proto/Example.btk

@@ -1,106 +0,0 @@
-// Single line comment.
-/* Mutiline comment.
-*/
-
-/* Enumeration Definition. */
-enum EnumName
-{
-	EN1,
-	EN2,
-	EN3,
-}
-
-enum EnumName16
-{
-	EN16_a01, EN16_a02, EN16_a03, EN16_a04, EN16_a05, EN16_a06, EN16_a07, EN16_a08,
-	EN16_a11, EN16_a12, EN16_a13, EN16_a14, EN16_a15, EN16_a16, EN16_a17, EN16_a18,
-	EN16_a21, EN16_a22, EN16_a23, EN16_a24, EN16_a25, EN16_a26, EN16_a27, EN16_a28,
-	EN16_a31, EN16_a32, EN16_a33, EN16_a34, EN16_a35, EN16_a36, EN16_a37, EN16_a38,
-	EN16_a41, EN16_a42, EN16_a43, EN16_a44, EN16_a45, EN16_a46, EN16_a47, EN16_a48,
-	EN16_a51, EN16_a52, EN16_a53, EN16_a54, EN16_a55, EN16_a56, EN16_a57, EN16_a58,
-	EN16_a61, EN16_a62, EN16_a63, EN16_a64, EN16_a65, EN16_a66, EN16_a67, EN16_a68,
-	EN16_a71, EN16_a72, EN16_a73, EN16_a74, EN16_a75, EN16_a76, EN16_a77, EN16_a78,
-
-	EN16_b01, EN16_b02, EN16_b03, EN16_b04, EN16_b05, EN16_b06, EN16_b07, EN16_b08,
-	EN16_b11, EN16_b12, EN16_b13, EN16_b14, EN16_b15, EN16_b16, EN16_b17, EN16_b18,
-	EN16_b21, EN16_b22, EN16_b23, EN16_b24, EN16_b25, EN16_b26, EN16_b27, EN16_b28,
-	EN16_b31, EN16_b32, EN16_b33, EN16_b34, EN16_b35, EN16_b36, EN16_b37, EN16_b38,
-	EN16_b41, EN16_b42, EN16_b43, EN16_b44, EN16_b45, EN16_b46, EN16_b47, EN16_b48,
-	EN16_b51, EN16_b52, EN16_b53, EN16_b54, EN16_b55, EN16_b56, EN16_b57, EN16_b58,
-	EN16_b61, EN16_b62, EN16_b63, EN16_b64, EN16_b65, EN16_b66, EN16_b67, EN16_b68,
-	EN16_b71, EN16_b72, EN16_b73, EN16_b74, EN16_b75, EN16_b76, EN16_b77, EN16_b78,
-
-	EN16_c01, EN16_c02, EN16_c03, EN16_c04, EN16_c05, EN16_c06, EN16_c07, EN16_c08,
-	EN16_c11, EN16_c12, EN16_c13, EN16_c14, EN16_c15, EN16_c16, EN16_c17, EN16_c18,
-	EN16_c21, EN16_c22, EN16_c23, EN16_c24, EN16_c25, EN16_c26, EN16_c27, EN16_c28,
-	EN16_c31, EN16_c32, EN16_c33, EN16_c34, EN16_c35, EN16_c36, EN16_c37, EN16_c38,
-	EN16_c41, EN16_c42, EN16_c43, EN16_c44, EN16_c45, EN16_c46, EN16_c47, EN16_c48,
-	EN16_c51, EN16_c52, EN16_c53, EN16_c54, EN16_c55, EN16_c56, EN16_c57, EN16_c58,
-	EN16_c61, EN16_c62, EN16_c63, EN16_c64, EN16_c65, EN16_c66, EN16_c67, EN16_c68,
-	EN16_c71, EN16_c72, EN16_c73, EN16_c74, EN16_c75, EN16_c76, EN16_c77, EN16_c78,
-
-	EN16_d01, EN16_d02, EN16_d03, EN16_d04, EN16_d05, EN16_d06, EN16_d07, EN16_d08,
-	EN16_d11, EN16_d12, EN16_d13, EN16_d14, EN16_d15, EN16_d16, EN16_d17, EN16_d18,
-	EN16_d21, EN16_d22, EN16_d23, EN16_d24, EN16_d25, EN16_d26, EN16_d27, EN16_d28,
-	EN16_d31, EN16_d32, EN16_d33, EN16_d34, EN16_d35, EN16_d36, EN16_d37, EN16_d38,
-	EN16_d41, EN16_d42, EN16_d43, EN16_d44, EN16_d45, EN16_d46, EN16_d47, EN16_d48,
-	EN16_d51, EN16_d52, EN16_d53, EN16_d54, EN16_d55, EN16_d56, EN16_d57, EN16_d58,
-	EN16_d61, EN16_d62, EN16_d63, EN16_d64, EN16_d65, EN16_d66, EN16_d67, EN16_d68,
-	EN16_d71, EN16_d72, EN16_d73, EN16_d74, EN16_d75, EN16_d76, EN16_d77, EN16_d78,
-
-	Max,
-}
-
-struct StructType
-{
-	string aaa_;
-	int32 bbb_;
-}
-
-/* Structure Definition.*/
-struct StructBase
-{
-	/* Basic types */
-	double 	double_;
-	float	float_;
-	int64	int64_;
-	uint64	uint64_;
-	int32	int32_;
-	uint32	uint32_;
-	int16	int16_;
-	uint16	uint16_;
-	int8	int8_;
-	uint8	uint8_;
-	bool	bool_;
-	// enum type.
-	EnumName enum_;
-	EnumName16 enum16_;
-	// struct type
-	StructType struct_;
-	// string type.
-	string	string_;
-	// string type with explicit max length.
-	string(32)	string1_;
-	// binary type.
-	binary	bin_;
-	// binary type with explicit max length.
-	binary(32) bin1_;
-	/* array type. */
-	double[] 	doubleArray_;
-	float[]		floatArray_;
-	int64[]		int64Array_;
-	uint64[]	uint64Array_;
-	int32[]		int32Array_;
-	uint32[]	uint32Array_;
-	int16[]		int16Array_;
-	uint16[]	uint16Array_;
-	int8[]		int8Array_;
-	uint8[]		uint8Array_;
-	bool[]		boolArray_;
-	string[] 	strArray_;
-	string(16)[8] strArray1_;
-	binary[] 	binArray_;
-	binary(32)[] 	bin1Array_;
-	EnumName[] enumArray_;
-	StructType[] structArray_;
-}

src/writeLua/ByteArray.lua

@@ -0,0 +1,271 @@
+BA_ENDIAN_BIG = "ENDIAN_BIG"						-- 大端
+BA_ENDIAN_LITTLE = "ENDIAN_LITTLE"					-- 小端
+
+function ByteArray(endian)
+	----------------------------------------------------------------------
+	-- private member variable
+	----------------------------------------------------------------------
+	local mRadix = {[8]="%03o", [10]="%03u", [16]="%02X"}		-- 进制
+	local mEndian = endian or ""								-- 大小端标识
+	local mBuf = {}												-- 二进制字节流
+	local mPos = 1												-- 读写位置
+	----------------------------------------------------------------------
+	-- private method
+	----------------------------------------------------------------------
+	-- 验证读写位置
+	local function checkAvailable()
+		assert(#mBuf >= mPos, string.format("End of file was encountered. pos: %d, length: %d.", mPos, #mBuf))
+	end
+	-- 获取字符码
+	local function getLetterCode(fmt)
+		fmt = fmt or ""
+		if BA_ENDIAN_LITTLE == mEndian then
+			return "<"..fmt
+		elseif BA_ENDIAN_BIG == mEndianthen then
+			return ">"..fmt
+		else
+			return "="..fmt
+		end
+	end
+	-- 读单个字节
+	local function readRawByte()
+		checkAvailable()
+		local rawByte = mBuf[mPos]
+		mPos = mPos + 1
+		return rawByte
+	end
+	-- 写单个字节
+	local function writeRawByte(rawByte)
+		if mPos > #mBuf + 1 then
+			for i=#mBuf + 1, mPos - 1 do
+				mBuf[i] = string.char(0)
+			end
+		end
+		mBuf[mPos] = rawByte
+		mPos = mPos + 1
+	end
+	-- 读字节流
+	local function readBuf(length)
+		checkAvailable()
+		local buf = table.concat(mBuf, "", mPos, mPos + length - 1)
+		mPos = mPos + length
+		return buf
+	end
+	-- 写字节流
+	local function writeBuf(buf)
+		for i=1, #buf do
+			writeRawByte(buf:sub(i, i))
+		end
+	end
+	-- 读字符串
+	local function read_string_bytes(length)
+		if 0 == length then
+			return ""
+		end
+		local tmp, value = string.unpack(readBuf(length), getLetterCode("A"..length))
+		return value
+	end
+	-- 写字符串
+	local function write_string_bytes(value)
+		local buf = string.pack(getLetterCode("A"), value)
+		writeBuf(buf)
+	end
+	----------------------------------------------------------------------
+	-- public method
+	----------------------------------------------------------------------
+	local ba = {}
+	-- 设置大小端
+	ba.setEndian = function(endian)
+		mEndian = endian or ""
+	end
+	-- 设置字节流
+	ba.setBytes = function(buf)
+		if #mBuf > 0 then
+			return
+		end
+		writeBuf(buf)
+		mPos = 1		-- 这里必须重置读写位置为1,方能保证接下去的读操作正确
+	end
+	-- 获取字节流
+	ba.getBytes = function()
+		local bytes = {}
+		for i=1, #mBuf do
+			bytes[#bytes+1] = string.byte(mBuf[i])
+		end
+		local packRes = string.pack(getLetterCode("b"..#bytes), unpack(bytes))
+		return packRes
+	end
+	-- 获取字节流长度
+	ba.getLength = function()
+		return #mBuf
+	end
+	-- 字节流转为字符串,radix-8,10,16
+	ba.toString = function(radix, separator)
+		radix = radix or 16
+		radix = mRadix[radix] or "%02X"
+		separator = separator or " "
+		local bytes = {}
+		for i=1, #mBuf do
+			bytes[i] = string.format(radix..separator, string.byte(mBuf[i]))
+		end
+		return table.concat(bytes)
+	end
+	----------------------------------------------------------------------
+	-- 读16位整型
+	ba.read_int16 = function()
+		local tmp, value = string.unpack(readBuf(2), getLetterCode("h"))
+		return value
+	end
+	-- 写16位整型
+	ba.write_int16 = function(value)
+		local buf = string.pack(getLetterCode("h"), value)
+		writeBuf(buf)
+	end
+	-- 读16位无符号整型
+	ba.read_uint16 = function()
+		local tmp, value = string.unpack(readBuf(2), getLetterCode("H"))
+		return value
+	end
+	-- 写16位无符号整型
+	ba.write_uint16 = function(value)
+        local sstr = getLetterCode("H")
+		local buf = string.pack(sstr, value)
+		writeBuf(buf)
+	end
+	-- 读32位整型
+	ba.read_int = function()
+		local tmp, value = string.unpack(readBuf(4), getLetterCode("i"))
+		return value
+	end
+	-- 写32位整型
+	ba.write_int = function(value)
+		local buf = string.pack(getLetterCode("i"), value)
+		writeBuf(buf)
+	end
+	-- 读32位无符号整型
+	ba.read_uint = function()
+		local tmp, value = string.unpack(readBuf(4), getLetterCode("I"))
+		return value
+	end
+	-- 写32位无符号整型
+	ba.write_uint = function(value)
+		local buf = string.pack(getLetterCode("I"), value)
+		writeBuf(buf)
+	end
+	-- 读长整型
+	ba.read_long = function()
+		local tmp, value = string.unpack(readBuf(4), getLetterCode("l"))
+		return value
+	end
+	-- 写长整型
+	ba.write_long = function(value)
+		local buf = string.pack(getLetterCode("l"), value)
+		writeBuf(buf)
+	end
+	-- 读无符号长整型
+	ba.read_ulong = function()
+		local tmp, value = string.unpack(readBuf(4), getLetterCode("L"))
+		return value
+	end
+	-- 写无符号长整型
+	ba.write_ulong = function(value)
+		local buf = string.pack(getLetterCode("L"), value)
+		writeBuf(buf)
+	end
+	-- 读64位整型
+	ba.read_int64 = function()
+		-- local tmp, value = string.unpack(readBuf(8), getLetterCode("m"))
+		-- return value
+		return read_string_bytes(8)
+	end
+	-- 写64位整型
+	ba.write_int64 = function(value)
+		-- local buf = string.pack(getLetterCode("m"), value)
+		-- writeBuf(buf)
+		local buf = string.pack(getLetterCode("A"), value)
+		writeBuf(buf)
+	end
+	-- 读64位无符号整型
+	ba.read_uint64 = function()
+		-- local tmp, value = string.unpack(readBuf(8), getLetterCode("M"))
+		-- return value
+		return read_string_bytes(8)
+	end
+	-- 写64位无符号整型
+	ba.write_uint64 = function(value)
+		-- local buf = string.pack(getLetterCode("M"), value)
+		-- writeBuf(buf)
+		local buf = string.pack(getLetterCode("A"), value)
+		writeBuf(buf)
+	end
+	-- 读单精度浮点型
+	ba.read_float = function()
+		local tmp, value = string.unpack(readBuf(4), getLetterCode("f"))
+		return value
+	end
+	-- 写单精度浮点型
+	ba.write_float = function(value)
+		local buf = string.pack(getLetterCode("f"), value)
+		writeBuf(buf)
+	end
+	-- 读双精度浮点型
+	ba.read_double = function()
+		local tmp, value = string.unpack(readBuf(8), getLetterCode("d"))
+		return value
+	end
+	-- 写双精度浮点型
+	ba.write_double = function(value)
+		local buf = string.pack(getLetterCode("d"), value)
+		writeBuf(buf)
+	end
+	-- 读布尔型
+	ba.read_bool = function()
+		return 1 == read_char()
+	end
+	-- 写布尔型
+	ba.write_bool = function(value)
+		if value then
+			ba.write_char(1)
+		else
+			ba.write_char(0)
+		end
+	end
+	-- 读字符型
+	ba.read_char = function()
+		local tmp, value = string.unpack(readRawByte(), "c")
+		return value
+	end
+	-- 写字符型
+	ba.write_char = function(value)
+		writeRawByte(string.pack("c", value))
+	end
+	-- 读单字节
+	ba.read_uchar = function()
+		-- 方法1
+		-- return string.byte(readRawByte())
+		-- 方法2
+		local tmp, value = string.unpack(readRawByte(), "b")
+		return value
+	end
+	-- 写单字节
+	ba.write_uchar = function(value)
+		-- 方法1
+		-- writeRawByte(string.char(value))
+		-- 方法2
+		writeRawByte(string.pack("b", value))
+	end
+	-- 读字符串
+	ba.read_string = function()
+		local length = ba.read_uint16()
+		return read_string_bytes(length)
+	end
+	-- 写字符串
+	ba.write_string = function(value)
+		local buf = string.pack(getLetterCode("A"), value)
+		ba.write_uint16(#buf)
+		writeBuf(buf)
+	end
+	----------------------------------------------------------------------
+	return ba
+end
+

src/writeLua/Example.lua

@@ -1,562 +0,0 @@
-require("bintalk.types")
-require("bintalk.reader")
-require("bintalk.writer")
-local EnumName = {
-	EN1 = 0,
-	EN2 = 1,
-	EN3 = 2,
-}
-EnumName = { _enum = EnumName }
-BintalkTypes.EnumName = setmetatable(EnumName, BintalkTypes._enum_mt)
-local EnumName16 = {
-	EN16_a01 = 0,
-	EN16_a02 = 1,
-	EN16_a03 = 2,
-	EN16_a04 = 3,
-	EN16_a05 = 4,
-	EN16_a06 = 5,
-	EN16_a07 = 6,
-	EN16_a08 = 7,
-	EN16_a11 = 8,
-	EN16_a12 = 9,
-	EN16_a13 = 10,
-	EN16_a14 = 11,
-	EN16_a15 = 12,
-	EN16_a16 = 13,
-	EN16_a17 = 14,
-	EN16_a18 = 15,
-	EN16_a21 = 16,
-	EN16_a22 = 17,
-	EN16_a23 = 18,
-	EN16_a24 = 19,
-	EN16_a25 = 20,
-	EN16_a26 = 21,
-	EN16_a27 = 22,
-	EN16_a28 = 23,
-	EN16_a31 = 24,
-	EN16_a32 = 25,
-	EN16_a33 = 26,
-	EN16_a34 = 27,
-	EN16_a35 = 28,
-	EN16_a36 = 29,
-	EN16_a37 = 30,
-	EN16_a38 = 31,
-	EN16_a41 = 32,
-	EN16_a42 = 33,
-	EN16_a43 = 34,
-	EN16_a44 = 35,
-	EN16_a45 = 36,
-	EN16_a46 = 37,
-	EN16_a47 = 38,
-	EN16_a48 = 39,
-	EN16_a51 = 40,
-	EN16_a52 = 41,
-	EN16_a53 = 42,
-	EN16_a54 = 43,
-	EN16_a55 = 44,
-	EN16_a56 = 45,
-	EN16_a57 = 46,
-	EN16_a58 = 47,
-	EN16_a61 = 48,
-	EN16_a62 = 49,
-	EN16_a63 = 50,
-	EN16_a64 = 51,
-	EN16_a65 = 52,
-	EN16_a66 = 53,
-	EN16_a67 = 54,
-	EN16_a68 = 55,
-	EN16_a71 = 56,
-	EN16_a72 = 57,
-	EN16_a73 = 58,
-	EN16_a74 = 59,
-	EN16_a75 = 60,
-	EN16_a76 = 61,
-	EN16_a77 = 62,
-	EN16_a78 = 63,
-	EN16_b01 = 64,
-	EN16_b02 = 65,
-	EN16_b03 = 66,
-	EN16_b04 = 67,
-	EN16_b05 = 68,
-	EN16_b06 = 69,
-	EN16_b07 = 70,
-	EN16_b08 = 71,
-	EN16_b11 = 72,
-	EN16_b12 = 73,
-	EN16_b13 = 74,
-	EN16_b14 = 75,
-	EN16_b15 = 76,
-	EN16_b16 = 77,
-	EN16_b17 = 78,
-	EN16_b18 = 79,
-	EN16_b21 = 80,
-	EN16_b22 = 81,
-	EN16_b23 = 82,
-	EN16_b24 = 83,
-	EN16_b25 = 84,
-	EN16_b26 = 85,
-	EN16_b27 = 86,
-	EN16_b28 = 87,
-	EN16_b31 = 88,
-	EN16_b32 = 89,
-	EN16_b33 = 90,
-	EN16_b34 = 91,
-	EN16_b35 = 92,
-	EN16_b36 = 93,
-	EN16_b37 = 94,
-	EN16_b38 = 95,
-	EN16_b41 = 96,
-	EN16_b42 = 97,
-	EN16_b43 = 98,
-	EN16_b44 = 99,
-	EN16_b45 = 100,
-	EN16_b46 = 101,
-	EN16_b47 = 102,
-	EN16_b48 = 103,
-	EN16_b51 = 104,
-	EN16_b52 = 105,
-	EN16_b53 = 106,
-	EN16_b54 = 107,
-	EN16_b55 = 108,
-	EN16_b56 = 109,
-	EN16_b57 = 110,
-	EN16_b58 = 111,
-	EN16_b61 = 112,
-	EN16_b62 = 113,
-	EN16_b63 = 114,
-	EN16_b64 = 115,
-	EN16_b65 = 116,
-	EN16_b66 = 117,
-	EN16_b67 = 118,
-	EN16_b68 = 119,
-	EN16_b71 = 120,
-	EN16_b72 = 121,
-	EN16_b73 = 122,
-	EN16_b74 = 123,
-	EN16_b75 = 124,
-	EN16_b76 = 125,
-	EN16_b77 = 126,
-	EN16_b78 = 127,
-	EN16_c01 = 128,
-	EN16_c02 = 129,
-	EN16_c03 = 130,
-	EN16_c04 = 131,
-	EN16_c05 = 132,
-	EN16_c06 = 133,
-	EN16_c07 = 134,
-	EN16_c08 = 135,
-	EN16_c11 = 136,
-	EN16_c12 = 137,
-	EN16_c13 = 138,
-	EN16_c14 = 139,
-	EN16_c15 = 140,
-	EN16_c16 = 141,
-	EN16_c17 = 142,
-	EN16_c18 = 143,
-	EN16_c21 = 144,
-	EN16_c22 = 145,
-	EN16_c23 = 146,
-	EN16_c24 = 147,
-	EN16_c25 = 148,
-	EN16_c26 = 149,
-	EN16_c27 = 150,
-	EN16_c28 = 151,
-	EN16_c31 = 152,
-	EN16_c32 = 153,
-	EN16_c33 = 154,
-	EN16_c34 = 155,
-	EN16_c35 = 156,
-	EN16_c36 = 157,
-	EN16_c37 = 158,
-	EN16_c38 = 159,
-	EN16_c41 = 160,
-	EN16_c42 = 161,
-	EN16_c43 = 162,
-	EN16_c44 = 163,
-	EN16_c45 = 164,
-	EN16_c46 = 165,
-	EN16_c47 = 166,
-	EN16_c48 = 167,
-	EN16_c51 = 168,
-	EN16_c52 = 169,
-	EN16_c53 = 170,
-	EN16_c54 = 171,
-	EN16_c55 = 172,
-	EN16_c56 = 173,
-	EN16_c57 = 174,
-	EN16_c58 = 175,
-	EN16_c61 = 176,
-	EN16_c62 = 177,
-	EN16_c63 = 178,
-	EN16_c64 = 179,
-	EN16_c65 = 180,
-	EN16_c66 = 181,
-	EN16_c67 = 182,
-	EN16_c68 = 183,
-	EN16_c71 = 184,
-	EN16_c72 = 185,
-	EN16_c73 = 186,
-	EN16_c74 = 187,
-	EN16_c75 = 188,
-	EN16_c76 = 189,
-	EN16_c77 = 190,
-	EN16_c78 = 191,
-	EN16_d01 = 192,
-	EN16_d02 = 193,
-	EN16_d03 = 194,
-	EN16_d04 = 195,
-	EN16_d05 = 196,
-	EN16_d06 = 197,
-	EN16_d07 = 198,
-	EN16_d08 = 199,
-	EN16_d11 = 200,
-	EN16_d12 = 201,
-	EN16_d13 = 202,
-	EN16_d14 = 203,
-	EN16_d15 = 204,
-	EN16_d16 = 205,
-	EN16_d17 = 206,
-	EN16_d18 = 207,
-	EN16_d21 = 208,
-	EN16_d22 = 209,
-	EN16_d23 = 210,
-	EN16_d24 = 211,
-	EN16_d25 = 212,
-	EN16_d26 = 213,
-	EN16_d27 = 214,
-	EN16_d28 = 215,
-	EN16_d31 = 216,
-	EN16_d32 = 217,
-	EN16_d33 = 218,
-	EN16_d34 = 219,
-	EN16_d35 = 220,
-	EN16_d36 = 221,
-	EN16_d37 = 222,
-	EN16_d38 = 223,
-	EN16_d41 = 224,
-	EN16_d42 = 225,
-	EN16_d43 = 226,
-	EN16_d44 = 227,
-	EN16_d45 = 228,
-	EN16_d46 = 229,
-	EN16_d47 = 230,
-	EN16_d48 = 231,
-	EN16_d51 = 232,
-	EN16_d52 = 233,
-	EN16_d53 = 234,
-	EN16_d54 = 235,
-	EN16_d55 = 236,
-	EN16_d56 = 237,
-	EN16_d57 = 238,
-	EN16_d58 = 239,
-	EN16_d61 = 240,
-	EN16_d62 = 241,
-	EN16_d63 = 242,
-	EN16_d64 = 243,
-	EN16_d65 = 244,
-	EN16_d66 = 245,
-	EN16_d67 = 246,
-	EN16_d68 = 247,
-	EN16_d71 = 248,
-	EN16_d72 = 249,
-	EN16_d73 = 250,
-	EN16_d74 = 251,
-	EN16_d75 = 252,
-	EN16_d76 = 253,
-	EN16_d77 = 254,
-	EN16_d78 = 255,
-	Max = 256,
-}
-EnumName16 = { _enum = EnumName16 }
-BintalkTypes.EnumName16 = setmetatable(EnumName16, BintalkTypes._enum_mt)
-local StructType = {
-	aaa_ = BintalkTypes.string(),
-	bbb_ = BintalkTypes.int32(),
-}
-BintalkTypes.StructType = function(v)
-	local _values = {
-		aaa_ = BintalkTypes.string(),
-		bbb_ = BintalkTypes.int32(),
-	}
-	local s = {_defaults = StructType, _values = _values}
-	setmetatable(s, BintalkTypes._struct_mt)
-	if not v then return s end
-	if v.aaa_ then
-		s.aaa_ = BintalkTypes.string(v.aaa_)
-	end
-	if v.bbb_ then
-		s.bbb_ = BintalkTypes.int32(v.bbb_)
-	end
-	return s
-end
-BintalkWriter.StructType = function(v, b)
-	BintalkWriter.string(v.aaa_, b)
-	BintalkWriter.int32(v.bbb_, b)
-end
-BintalkReader.StructType = function(b, p)
-	local v = BintalkTypes.StructType()
-	v.aaa_, p = BintalkReader.string(b, p, 0XFFFFFFFF)
-	v.bbb_, p = BintalkReader.int32(b, p, 0X0)
-	return v, p
-end
-local StructBase = {
-	double_ = BintalkTypes.double(),
-	float_ = BintalkTypes.float(),
-	int64_ = BintalkTypes.int64(),
-	uint64_ = BintalkTypes.uint64(),
-	int32_ = BintalkTypes.int32(),
-	uint32_ = BintalkTypes.uint32(),
-	int16_ = BintalkTypes.int16(),
-	uint16_ = BintalkTypes.uint16(),
-	int8_ = BintalkTypes.int8(),
-	uint8_ = BintalkTypes.uint8(),
-	bool_ = BintalkTypes.bool(),
-	enum_ = BintalkTypes.enum(),
-	enum16_ = BintalkTypes.enum16(),
-	struct_ = BintalkTypes.StructType(),
-	string_ = BintalkTypes.string(),
-	string1_ = BintalkTypes.string(),
-	bin_ = BintalkTypes.binary(),
-	bin1_ = BintalkTypes.binary(),
-	doubleArray_ = BintalkTypes.array(BintalkTypes.double),
-	floatArray_ = BintalkTypes.array(BintalkTypes.float),
-	int64Array_ = BintalkTypes.array(BintalkTypes.int64),
-	uint64Array_ = BintalkTypes.array(BintalkTypes.uint64),
-	int32Array_ = BintalkTypes.array(BintalkTypes.int32),
-	uint32Array_ = BintalkTypes.array(BintalkTypes.uint32),
-	int16Array_ = BintalkTypes.array(BintalkTypes.int16),
-	uint16Array_ = BintalkTypes.array(BintalkTypes.uint16),
-	int8Array_ = BintalkTypes.array(BintalkTypes.int8),
-	uint8Array_ = BintalkTypes.array(BintalkTypes.uint8),
-	boolArray_ = BintalkTypes.array(BintalkTypes.bool),
-	strArray_ = BintalkTypes.array(BintalkTypes.string),
-	strArray1_ = BintalkTypes.array(BintalkTypes.string),
-	binArray_ = BintalkTypes.array(BintalkTypes.binary),
-	bin1Array_ = BintalkTypes.array(BintalkTypes.binary),
-	enumArray_ = BintalkTypes.array(BintalkTypes.enum),
-	structArray_ = BintalkTypes.array(BintalkTypes.StructType),
-}
-BintalkTypes.StructBase = function(v)
-	local _values = {
-		double_ = BintalkTypes.double(),
-		float_ = BintalkTypes.float(),
-		int64_ = BintalkTypes.int64(),
-		uint64_ = BintalkTypes.uint64(),
-		int32_ = BintalkTypes.int32(),
-		uint32_ = BintalkTypes.uint32(),
-		int16_ = BintalkTypes.int16(),
-		uint16_ = BintalkTypes.uint16(),
-		int8_ = BintalkTypes.int8(),
-		uint8_ = BintalkTypes.uint8(),
-		bool_ = BintalkTypes.bool(),
-		enum_ = BintalkTypes.enum(),
-		enum16_ = BintalkTypes.enum16(),
-		struct_ = BintalkTypes.StructType(),
-		string_ = BintalkTypes.string(),
-		string1_ = BintalkTypes.string(),
-		bin_ = BintalkTypes.binary(),
-		bin1_ = BintalkTypes.binary(),
-		doubleArray_ = BintalkTypes.array(BintalkTypes.double),
-		floatArray_ = BintalkTypes.array(BintalkTypes.float),
-		int64Array_ = BintalkTypes.array(BintalkTypes.int64),
-		uint64Array_ = BintalkTypes.array(BintalkTypes.uint64),
-		int32Array_ = BintalkTypes.array(BintalkTypes.int32),
-		uint32Array_ = BintalkTypes.array(BintalkTypes.uint32),
-		int16Array_ = BintalkTypes.array(BintalkTypes.int16),
-		uint16Array_ = BintalkTypes.array(BintalkTypes.uint16),
-		int8Array_ = BintalkTypes.array(BintalkTypes.int8),
-		uint8Array_ = BintalkTypes.array(BintalkTypes.uint8),
-		boolArray_ = BintalkTypes.array(BintalkTypes.bool),
-		strArray_ = BintalkTypes.array(BintalkTypes.string),
-		strArray1_ = BintalkTypes.array(BintalkTypes.string),
-		binArray_ = BintalkTypes.array(BintalkTypes.binary),
-		bin1Array_ = BintalkTypes.array(BintalkTypes.binary),
-		enumArray_ = BintalkTypes.array(BintalkTypes.enum),
-		structArray_ = BintalkTypes.array(BintalkTypes.StructType),
-	}
-	local s = {_defaults = StructBase, _values = _values}
-	setmetatable(s, BintalkTypes._struct_mt)
-	if not v then return s end
-	if v.double_ then
-		s.double_ = BintalkTypes.double(v.double_)
-	end
-	if v.float_ then
-		s.float_ = BintalkTypes.float(v.float_)
-	end
-	if v.int64_ then
-		s.int64_ = BintalkTypes.int64(v.int64_)
-	end
-	if v.uint64_ then
-		s.uint64_ = BintalkTypes.uint64(v.uint64_)
-	end
-	if v.int32_ then
-		s.int32_ = BintalkTypes.int32(v.int32_)
-	end
-	if v.uint32_ then
-		s.uint32_ = BintalkTypes.uint32(v.uint32_)
-	end
-	if v.int16_ then
-		s.int16_ = BintalkTypes.int16(v.int16_)
-	end
-	if v.uint16_ then
-		s.uint16_ = BintalkTypes.uint16(v.uint16_)
-	end
-	if v.int8_ then
-		s.int8_ = BintalkTypes.int8(v.int8_)
-	end
-	if v.uint8_ then
-		s.uint8_ = BintalkTypes.uint8(v.uint8_)
-	end
-	if v.bool_ then
-		s.bool_ = BintalkTypes.bool(v.bool_)
-	end
-	if v.enum_ then
-		s.enum_ = BintalkTypes.enum(v.enum_)
-	end
-	if v.enum16_ then
-		s.enum16_ = BintalkTypes.enum16(v.enum16_)
-	end
-	if v.struct_ then
-		s.struct_ = BintalkTypes.StructType(v.struct_)
-	end
-	if v.string_ then
-		s.string_ = BintalkTypes.string(v.string_)
-	end
-	if v.string1_ then
-		s.string1_ = BintalkTypes.string(v.string1_)
-	end
-	if v.bin_ then
-		s.bin_ = BintalkTypes.binary(v.bin_)
-	end
-	if v.bin1_ then
-		s.bin1_ = BintalkTypes.binary(v.bin1_)
-	end
-	if v.doubleArray_ then
-		s.doubleArray_ = BintalkTypes.array(BintalkTypes.double, v.doubleArray_)
-	end
-	if v.floatArray_ then
-		s.floatArray_ = BintalkTypes.array(BintalkTypes.float, v.floatArray_)
-	end
-	if v.int64Array_ then
-		s.int64Array_ = BintalkTypes.array(BintalkTypes.int64, v.int64Array_)
-	end
-	if v.uint64Array_ then
-		s.uint64Array_ = BintalkTypes.array(BintalkTypes.uint64, v.uint64Array_)
-	end
-	if v.int32Array_ then
-		s.int32Array_ = BintalkTypes.array(BintalkTypes.int32, v.int32Array_)
-	end
-	if v.uint32Array_ then
-		s.uint32Array_ = BintalkTypes.array(BintalkTypes.uint32, v.uint32Array_)
-	end
-	if v.int16Array_ then
-		s.int16Array_ = BintalkTypes.array(BintalkTypes.int16, v.int16Array_)
-	end
-	if v.uint16Array_ then
-		s.uint16Array_ = BintalkTypes.array(BintalkTypes.uint16, v.uint16Array_)
-	end
-	if v.int8Array_ then
-		s.int8Array_ = BintalkTypes.array(BintalkTypes.int8, v.int8Array_)
-	end
-	if v.uint8Array_ then
-		s.uint8Array_ = BintalkTypes.array(BintalkTypes.uint8, v.uint8Array_)
-	end
-	if v.boolArray_ then
-		s.boolArray_ = BintalkTypes.array(BintalkTypes.bool, v.boolArray_)
-	end
-	if v.strArray_ then
-		s.strArray_ = BintalkTypes.array(BintalkTypes.string, v.strArray_)
-	end
-	if v.strArray1_ then
-		s.strArray1_ = BintalkTypes.array(BintalkTypes.string, v.strArray1_)
-	end
-	if v.binArray_ then
-		s.binArray_ = BintalkTypes.array(BintalkTypes.binary, v.binArray_)
-	end
-	if v.bin1Array_ then
-		s.bin1Array_ = BintalkTypes.array(BintalkTypes.binary, v.bin1Array_)
-	end
-	if v.enumArray_ then
-		s.enumArray_ = BintalkTypes.array(BintalkTypes.enum, v.enumArray_)
-	end
-	if v.structArray_ then
-		s.structArray_ = BintalkTypes.array(BintalkTypes.StructType, v.structArray_)
-	end
-	return s
-end
-BintalkWriter.StructBase = function(v, b)
-	BintalkWriter.double(v.double_, b)
-	BintalkWriter.float(v.float_, b)
-	BintalkWriter.int64(v.int64_, b)
-	BintalkWriter.uint64(v.uint64_, b)
-	BintalkWriter.int32(v.int32_, b)
-	BintalkWriter.uint32(v.uint32_, b)
-	BintalkWriter.int16(v.int16_, b)
-	BintalkWriter.uint16(v.uint16_, b)
-	BintalkWriter.int8(v.int8_, b)
-	BintalkWriter.uint8(v.uint8_, b)
-	BintalkWriter.bool(v.bool_, b)
-	BintalkWriter.enum(v.enum_, b)
-	BintalkWriter.enum16(v.enum16_, b)
-	BintalkWriter.StructType(v.struct_, b)
-	BintalkWriter.string(v.string_, b)
-	BintalkWriter.string(v.string1_, b)
-	BintalkWriter.binary(v.bin_, b)
-	BintalkWriter.binary(v.bin1_, b)
-	BintalkWriter.array(BintalkWriter.double, v.doubleArray_, b)
-	BintalkWriter.array(BintalkWriter.float, v.floatArray_, b)
-	BintalkWriter.array(BintalkWriter.int64, v.int64Array_, b)
-	BintalkWriter.array(BintalkWriter.uint64, v.uint64Array_, b)
-	BintalkWriter.array(BintalkWriter.int32, v.int32Array_, b)
-	BintalkWriter.array(BintalkWriter.uint32, v.uint32Array_, b)
-	BintalkWriter.array(BintalkWriter.int16, v.int16Array_, b)
-	BintalkWriter.array(BintalkWriter.uint16, v.uint16Array_, b)
-	BintalkWriter.array(BintalkWriter.int8, v.int8Array_, b)
-	BintalkWriter.array(BintalkWriter.uint8, v.uint8Array_, b)
-	BintalkWriter.array(BintalkWriter.bool, v.boolArray_, b)
-	BintalkWriter.array(BintalkWriter.string, v.strArray_, b)
-	BintalkWriter.array(BintalkWriter.string, v.strArray1_, b)
-	BintalkWriter.array(BintalkWriter.binary, v.binArray_, b)
-	BintalkWriter.array(BintalkWriter.binary, v.bin1Array_, b)
-	BintalkWriter.array(BintalkWriter.enum, v.enumArray_, b)
-	BintalkWriter.array(BintalkWriter.StructType, v.structArray_, b)
-end
-BintalkReader.StructBase = function(b, p)
-	local v = BintalkTypes.StructBase()
-	v.double_, p = BintalkReader.double(b, p, 0X0)
-	v.float_, p = BintalkReader.float(b, p, 0X0)
-	v.int64_, p = BintalkReader.int64(b, p, 0X0)
-	v.uint64_, p = BintalkReader.uint64(b, p, 0X0)
-	v.int32_, p = BintalkReader.int32(b, p, 0X0)
-	v.uint32_, p = BintalkReader.uint32(b, p, 0X0)
-	v.int16_, p = BintalkReader.int16(b, p, 0X0)
-	v.uint16_, p = BintalkReader.uint16(b, p, 0X0)
-	v.int8_, p = BintalkReader.int8(b, p, 0X0)
-	v.uint8_, p = BintalkReader.uint8(b, p, 0X0)
-	v.bool_, p = BintalkReader.bool(b, p, 0X0)
-	v.enum_, p = BintalkReader.enum(b, p, 0X2)
-	v.enum16_, p = BintalkReader.enum16(b, p, 0X100)
-	v.struct_, p = BintalkReader.StructType(b, p, 0X0)
-	v.string_, p = BintalkReader.string(b, p, 0XFFFFFFFF)
-	v.string1_, p = BintalkReader.string(b, p, 0X20)
-	v.bin_, p = BintalkReader.binary(b, p, 0XFFFFFFFF)
-	v.bin1_, p = BintalkReader.binary(b, p, 0X20)
-	v.doubleArray_, p = BintalkReader.array(b, p, BintalkReader.double, 0XFFFFFFFF, 0X0)
-	v.floatArray_, p = BintalkReader.array(b, p, BintalkReader.float, 0XFFFFFFFF, 0X0)
-	v.int64Array_, p = BintalkReader.array(b, p, BintalkReader.int64, 0XFFFFFFFF, 0X0)
-	v.uint64Array_, p = BintalkReader.array(b, p, BintalkReader.uint64, 0XFFFFFFFF, 0X0)
-	v.int32Array_, p = BintalkReader.array(b, p, BintalkReader.int32, 0XFFFFFFFF, 0X0)
-	v.uint32Array_, p = BintalkReader.array(b, p, BintalkReader.uint32, 0XFFFFFFFF, 0X0)
-	v.int16Array_, p = BintalkReader.array(b, p, BintalkReader.int16, 0XFFFFFFFF, 0X0)
-	v.uint16Array_, p = BintalkReader.array(b, p, BintalkReader.uint16, 0XFFFFFFFF, 0X0)
-	v.int8Array_, p = BintalkReader.array(b, p, BintalkReader.int8, 0XFFFFFFFF, 0X0)
-	v.uint8Array_, p = BintalkReader.array(b, p, BintalkReader.uint8, 0XFFFFFFFF, 0X0)
-	v.boolArray_, p = BintalkReader.array(b, p, BintalkReader.bool, 0XFFFFFFFF, 0X0)
-	v.strArray_, p = BintalkReader.array(b, p, BintalkReader.string, 0XFFFFFFFF, 0XFFFFFFFF)
-	v.strArray1_, p = BintalkReader.array(b, p, BintalkReader.string, 0X8, 0X10)
-	v.binArray_, p = BintalkReader.array(b, p, BintalkReader.binary, 0XFFFFFFFF, 0XFFFFFFFF)
-	v.bin1Array_, p = BintalkReader.array(b, p, BintalkReader.binary, 0XFFFFFFFF, 0X20)
-	v.enumArray_, p = BintalkReader.array(b, p, BintalkReader.enum, 0XFFFFFFFF, 0X2)
-	v.structArray_, p = BintalkReader.array(b, p, BintalkReader.StructType, 0XFFFFFFFF, 0X0)
-	return v, p
-end

src/writeLua/LUAGenerator.cpp

@@ -1,161 +0,0 @@
-#include "Options.h"
-#include "Context.h"
-#include "CodeFile.h"
-
-#include "CodeGenerator.h"
-DECLARE_CG(LUAGenerator, lua);
-
-static void generateEnum(CodeFile& f, Enum* e)
-{
-    const char* name = e->getNameC();
-    f.output("local %s = {", name);
-    f.indent();
-    for (size_t i = 0; i < e->items_.size(); i++)
-        f.output("%s = %d,", e->items_[i].c_str(), i);
-    f.recover();
-    f.output("}");
-    f.output("%s = { _enum = %s }", name, name);
-    f.output("BintalkTypes.%s = setmetatable(%s, BintalkTypes._enum_mt)", name, name);
-}
-
-static const char* getFieldTypeName(Field& f)
-{
-    switch (f.type_)
-    {
-    case Field::FT_INT64:   return "int64";
-    case Field::FT_UINT64:  return "uint64";
-    case Field::FT_DOUBLE:  return "double";
-    case Field::FT_FLOAT:   return "float";
-    case Field::FT_INT32:   return "int32";
-    case Field::FT_UINT32:  return "uint32";
-    case Field::FT_INT16:   return "int16";
-    case Field::FT_UINT16:  return "uint16";
-    case Field::FT_INT8:    return "int8";
-    case Field::FT_UINT8:   return "uint8";
-    case Field::FT_BOOL:    return "bool";
-    case Field::FT_STRING:  return "string";
-    case Field::FT_USER:    return f.userType_->getNameC();
-	case Field::FT_ENUM:    return f.userType_->getEnum()->isEnum16()?"enum16":"enum";
-    case Field::FT_BINARY:  return "binary";
-    }
-    return "";
-}
-
-static void generateFieldDefaults(CodeFile& f, FieldContainer* fc)
-{
-    for (size_t i = 0; i < fc->fields_.size(); i++)
-    {
-        Field& field = fc->fields_[i];
-        const char* name = field.getNameC();
-        const char* type = getFieldTypeName(field);
-        if (field.isArray())
-            f.output("%s = BintalkTypes.array(BintalkTypes.%s),", name, type);
-        else
-            f.output("%s = BintalkTypes.%s(),", name, type);
-    }
-}
-static void generateFieldInitCode(CodeFile& f, FieldContainer* fc)
-{
-    for (size_t i = 0; i < fc->fields_.size(); i++)
-    {
-        Field& field = fc->fields_[i];
-        const char* name = field.getNameC();
-        const char* type = getFieldTypeName(field);
-        f.output("if v.%s then", name);
-        f.indent();
-        if (field.isArray())
-            f.output("s.%s = BintalkTypes.array(BintalkTypes.%s, v.%s)", name, type, name);
-        else
-            f.output("s.%s = BintalkTypes.%s(v.%s)", name, type, name);
-        f.recover();
-        f.output("end");
-    }
-}
-static void generateFieldContainerSCode(CodeFile& f, FieldContainer* fc)
-{
-    for (size_t i = 0; i < fc->fields_.size(); i++)
-    {
-        Field& field = fc->fields_[i];
-        if (field.isArray())
-            f.output("BintalkWriter.array(BintalkWriter.%s, v.%s, b)", getFieldTypeName(field), field.getNameC());
-        else
-            f.output("BintalkWriter.%s(v.%s, b)", getFieldTypeName(field), field.getNameC());
-    }
-}
-static void generateFieldContainerDSCode(CodeFile& f, FieldContainer* fc)
-{
-    for (size_t i = 0; i < fc->fields_.size(); i++)
-    {
-        Field& field = fc->fields_[i];
-        if (field.isArray())
-            f.output("v.%s, p = BintalkReader.array(b, p, BintalkReader.%s, 0X%X, 0X%X)", field.getNameC(), getFieldTypeName(field), field.maxArray_, field.maxValue_);
-        else
-            f.output("v.%s, p = BintalkReader.%s(b, p, 0X%X)", field.getNameC(), getFieldTypeName(field), field.maxValue_);
-    }
-}
-
-static void generateStruct(CodeFile& f, Struct* s)
-{
-    const char* name = s->getNameC();
-
-    f.output("local %s = {", name);
-    f.indent();
-    generateFieldDefaults(f, s);
-    f.recover();
-    f.output("}");
-
-    f.output("BintalkTypes.%s = function(v)", name);
-    f.indent();
-    f.output("local _values = {");
-    f.indent();
-    generateFieldDefaults(f, s);
-    f.recover();
-    f.output("}");
-    f.output("local s = {_defaults = %s, _values = _values}", name);
-    f.output("setmetatable(s, BintalkTypes._struct_mt)");
-    f.output("if not v then return s end");
-    generateFieldInitCode(f, s);
-    f.output("return s");
-    f.recover();
-    f.output("end");
-
-    f.output("BintalkWriter.%s = function(v, b)", s->getNameC());
-    f.indent();
-    generateFieldContainerSCode(f, s);
-    f.recover();
-    f.output("end");
-
-    f.output("BintalkReader.%s = function(b, p)", s->getNameC());
-    f.indent();
-    f.output("local v = BintalkTypes.%s()", s->getNameC());
-    generateFieldContainerDSCode(f, s);
-    f.output("return v, p");
-    f.recover();
-    f.output("end");
-}
-
-void LUAGenerator::generate()
-{
-    std::string fn = gOptions.output_ + gOptions.inputFS_ + ".lua";
-    CodeFile f(fn);
-    f.output("require(\"bintalk.types\")");
-    f.output("require(\"bintalk.reader\")");
-    f.output("require(\"bintalk.writer\")");
-    for (std::set<std::string>::iterator iter = gContext.imported_.begin();
-        iter != gContext.imported_.end(); ++iter)
-    {
-        std::string incFilename = *iter;
-        incFilename = incFilename.substr(0, incFilename.find('.'));
-        f.output("require(\"btk_gen.%s\")", incFilename.c_str());
-    }
-    for (size_t i = 0; i < gContext.definitions_.size(); i++)
-    {
-        Definition* definition = gContext.definitions_[i];
-        if (definition->file_ != gOptions.inputFN_)
-            continue;
-        if (definition->getEnum())
-            generateEnum(f, definition->getEnum());
-        else if (definition->getStruct())
-            generateStruct(f, definition->getStruct());
-    }
-}

src/writeLua/gLuaField.erl

@@ -0,0 +1,50 @@
+-module(gLuaField).
+
+-compile([export_all, nowarn_export_all]).
+
+-define(SimpleList, [
+   <<"int8">>
+   , <<"uint8">>
+   , <<"int16">>
+   , <<"uint16">>
+   , <<"int32">>
+   , <<"uint32">>
+   , <<"int64">>
+   , <<"uint64">>
+   , <<"float">>
+   , <<"double">>
+]).
+
+-define(TypeValue, [
+   {<<"bool">>, <<"bool">>}
+   , {<<"int8">>, <<"sbyte">>}
+   , {<<"uint8">>, <<"byte">>}
+   , {<<"int16">>, <<"short">>}
+   , {<<"uint16">>, <<"ushort">>}
+   , {<<"int32">>, <<"int">>}
+   , {<<"uint32">>, <<"uint">>}
+   , {<<"int64">>, <<"long">>}
+   , {<<"uint64">>, <<"ulong">>}
+   , {<<"float">>, <<"float">>}
+   , {<<"double">>, <<"double">>}
+   , {<<"string">>, <<"string">>}
+]).
+
+builtRecStr({TypeStr, NameStr}) ->
+   case lists:keyfind(TypeStr, 1, ?TypeValue) of
+      {TypeStr, CSTypeStr} ->
+         <<"\t\tpublic ", CSTypeStr/binary, " ", NameStr/binary, ";\n">>;
+      _ ->
+         case TypeStr of
+            <<"list[", LeftStr/binary>> ->
+               [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
+               case lists:keyfind(SubTypeStr, 1, ?TypeValue) of
+                  {SubTypeStr, SubCSTypeStr} ->
+                     <<"\t\tpublic List<", SubCSTypeStr/binary, "> ", NameStr/binary, ";\n">>;
+                  _ ->
+                     <<"\t\tpublic List<", SubTypeStr/binary, "> ", NameStr/binary, ";\n">>
+               end;
+            _ ->
+               <<"\t\tpublic ", TypeStr/binary, " ", NameStr/binary, ";\n">>
+         end
+   end.

src/writeLua/gLuaGen.erl

@@ -0,0 +1,397 @@
+%% Author: NoteBook
+%% Created: 2009-9-18
+%% Description: TODO: Add description to gen_protocal_charp
+-module(gLuaGen).
+
+%%
+%% Include files
+%%
+
+%%
+%% Exported Functions
+%%
+-export([start/0]).
+-export([test/0]).
+%%
+%% API Functions
+%%
+
+start() ->
+    StructList = protocol_def:get_struct_def(),
+    TypeList = gen_common:get_type(),
+    FileStr = make_protocal(StructList, "", TypeList),
+		%%根据前端需求更改 原：file:write_file("NetPacket.lua",  FileStr),
+%%	file:write_file("NetPacket.lua",  lists:concat(["return {", FileStr, "}"])),
+		file:write_file("NetPacket.lua",  FileStr),
+    EnumStr = make_protocal_enum(protocol_def:get_enum_def(), ""),
+    ConstStr = make_protocal_const(protocol_def:get_version()),
+    file:write_file("NetEnumDef.lua",  EnumStr ++ "\n" ++ ConstStr),
+    MsgTypeStr = make_protocal_msg_type(StructList, "", 1),
+    file:write_file("NetMsgType.lua", MsgTypeStr).
+
+%%
+%% Local Functions
+%%
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成包含文件%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%% make_include() ->
+%%     "using System;
+%% using System.Collections;".
+    %% "#pragma once
+    %% #include\"ByteArray.h\"
+    %% #include\"BaseType.h\"
+    %% #include\"INetPacket.h\"
+    %% #include\"NetMsgType.h\"
+    %% #include<string>
+    %% #include<vector>
+    %% ".
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成函数的方法%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+make_protocal([], StructStr, _TypeList) ->
+    StructStr;
+make_protocal([Struct | Structs], StructStr, TypeList) ->
+    [StructName | NewStructList] = Struct,
+    VariableStr = make_protocal_Variable(NewStructList, "", TypeList),
+    EncodeStr = make_protocal_encode(NewStructList, "", TypeList),
+    DecodeStr = make_protocal_decode(NewStructList, "", TypeList),
+    BuildStr = make_protocal_build(StructName),
+    CreateStr = make_protocal_create(StructName),
+    StructStr1 = StructStr ++ "\nfunction " ++ atom_to_list(StructName) ++ " ()" ++
+	"\n" ++ 
+	"    local tb = {}\n" ++
+	make_getmsgid(StructName) ++
+	%% "    public int getMsgID()\n" ++
+	%% "    {\n" ++
+        %% "        return NetMsgType.msg_" ++ atom_to_list(StructName) ++ ";\n" ++
+        %% "    }\n" ++
+	VariableStr ++ EncodeStr ++ DecodeStr ++ BuildStr ++ CreateStr ++ "\nend\n",
+    make_protocal(Structs, StructStr1, TypeList).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成变量%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+make_protocal_Variable([], VariableStr, _TypeList) ->
+    VariableStr;
+make_protocal_Variable([{Type, Name} | Vars], VariableStr, TypeList) ->
+    VariableStr1 = 
+	case lists:keyfind(Type, 1, TypeList) of
+	    {_Type1, base_type} ->
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = 0\n";
+	    {_Type1, string_type}  -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = \"\"\n";
+	    {_Type, enum_type} ->
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = 0\n";
+	    _ -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = {}\n"
+	end,
+    make_protocal_Variable(Vars, VariableStr1, TypeList);
+
+make_protocal_Variable([{Type, Name, DefaultValue} | Vars], VariableStr, TypeList) 
+  when Type =/= array ->
+    VariableStr1 = 
+	case lists:keyfind(Type, 1, TypeList) of
+	    {_Type1, base_type} ->
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = " ++ get_default_value(Type, DefaultValue) ++ "\n";
+	    {_Type1, string_type}  -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = " ++ get_default_value(Type, DefaultValue) ++ ";\n";
+	    {_Type, enum_type} ->
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = 0\n";
+	    _ -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = {}\n"
+	end,
+    make_protocal_Variable(Vars, VariableStr1, TypeList);
+
+make_protocal_Variable([{array, Type, Name} | Vars], VariableStr, TypeList) ->
+    VariableStr1 = 
+	case lists:keyfind(Type, 1, TypeList) of
+	    {_Type1, base_type} ->
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = {}\n";
+	    {_Type1, string_type}  -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = {}\n";
+	    {_Type, enum_type} ->
+		VariableStr ++ "    tb." ++ atom_to_list(Name) ++ " = {}\n";
+	    _ -> 
+		VariableStr ++ "    tb." ++ get_csharp_Var(Name) ++ " = {}\n"
+	end,
+    make_protocal_Variable(Vars, VariableStr1, TypeList).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+make_protocal_build(StructName) ->
+    "\n    tb.build = function(byteArray)\n" ++ 
+    "        byteArray.write_uint16(NetMsgType[\"msg_" ++ atom_to_list(StructName) ++ "\"])\n" ++
+    "        return tb.encode(byteArray)\n" ++
+    "    end\n".
+
+make_protocal_create(_StructName)->
+    "\n    return tb\n".
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成encode%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% byteArray.write_uint16(account.size());
+%%         for(int i=0; i<account.size();i++)
+%%         {
+%%             byteArray.write_string(account[i]);
+%%         } 
+make_protocal_encode([], EncodeStr, _TypeList) ->
+    "\n    tb.encode = function(byteArray)\n" 
+	++ EncodeStr ++ "        return byteArray\n" 
+	++ "    end\n\n";
+make_protocal_encode([Struct | Vars], EncodeStr, TypeList) ->
+    EncodeStr1 = EncodeStr ++ make_protocal_encode_item(Struct, TypeList),
+    make_protocal_encode(Vars, EncodeStr1, TypeList).
+
+%% 生成decode中的数组 
+make_protocal_encode_item({Type, Name}, TypeList) ->
+    case lists:keyfind(Type, 1, TypeList) of
+	{Type, base_type} ->
+	    "    \tbyteArray.write_"++ atom_to_list(Type) ++"(tb." ++ get_csharp_Var(Name) ++ ")\n";
+	{Type, string_type}  -> 
+	    "    \tbyteArray.write_"++ atom_to_list(Type) ++"(tb." ++ get_csharp_Var(Name) ++ ")\n";
+	{_Type, enum_type} ->
+	    make_protocal_encode_item({int, Name}, TypeList);
+	_ -> 
+    	      "        tb." ++ get_csharp_Var(Name) ++ ".encode(byteArray);\n"
+	    %%"        " ++  get_csharp_Var(Name) ++ ".encode(byteArray)\n\n"
+    end;
+make_protocal_encode_item({Type, Name, _DefaultValue}, TypeList) 
+  when Type /= array->
+    make_protocal_encode_item({Type, Name}, TypeList);
+make_protocal_encode_item({array, Type, Name}, TypeList) ->
+    case lists:keyfind(Type, 1, TypeList) of
+	{Type1, base_type} ->
+	    make_protocal_encode_item_base_type(Name, Type1);
+	{Type1, string_type}  -> 
+	    make_protocal_encode_item_base_type(Name, Type1);
+	{_Type, enum_type} ->
+	    make_protocal_encode_item({array, int, Name}, TypeList);
+	_ -> 
+	    NameStr = get_csharp_Var(Name),
+	    "        byteArray.write_uint16(#(tb." ++ NameStr ++ "))\n" ++
+	    "        for k, v in pairs(tb." ++ NameStr ++ ") do\n" ++
+	    "            byteArray = v.encode(byteArray)\n" ++
+            "        end\n"
+    end.
+
+make_protocal_encode_item_base_type(Name, Type) ->
+    NameStr = get_csharp_Var(Name),
+    TypeStr = get_csharp_type(Type),
+    "        byteArray.write_uint16(#(tb." ++ NameStr ++ "))\n" ++
+    "        for k, v in pairs (tb." ++ NameStr ++ ") do\n" ++ 
+    "            byteArray.write_" ++ TypeStr  ++ "(v)\n" ++ 
+    "        end\n".
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成decode%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+make_protocal_decode([], DecodeStr, _TypeList) ->
+    "    tb.decode = function(byteArray)\n" ++ DecodeStr ++ "    end\n";
+make_protocal_decode([Struct | Vars], DecodeStr, TypeList) ->
+    DecodeStr1 = DecodeStr ++  make_protocal_decode_item(Struct, TypeList),
+    make_protocal_decode(Vars, DecodeStr1, TypeList).
+
+make_protocal_decode_item({Type, Name}, TypeList) ->
+    case lists:keyfind(Type, 1, TypeList) of
+	{Type1, base_type} ->
+	    "        tb." ++ get_csharp_Var(Name) ++ " = byteArray.read_"++ atom_to_list(Type1) ++"();\n";
+	{Type1, string_type}  -> 
+	    "        tb." ++ get_csharp_Var(Name) ++ " = byteArray.read_"++ atom_to_list(Type1) ++"();\n";
+	{_Type, enum_type} ->
+	    make_protocal_decode_item({int, Name}, TypeList);
+	_ ->
+	    TypeString = get_csharp_type(Type),
+	      "        tb." ++ get_csharp_Var(Name) ++ " = " ++ TypeString ++ "();\n" ++
+    	      "        tb." ++ get_csharp_Var(Name) ++ ".decode(byteArray);\n"
+	    %%"        " ++ get_csharp_Var(Name) ++ ".decode(byteArray);\n"
+    end;
+make_protocal_decode_item({Type, Name, _DefaultValue}, TypeList)
+  when Type /= array->
+    make_protocal_decode_item({Type, Name}, TypeList);
+make_protocal_decode_item({array, Type, Name}, TypeList) ->
+    case lists:keyfind(Type, 1, TypeList) of
+	{Type1, base_type} ->
+	    make_protocal_encode_item_decode_type(Name, Type1);
+	{Type1, string_type}  -> 
+	    make_protocal_encode_item_decode_type(Name, Type1);
+	{_Type, enum_type} ->
+	    make_protocal_decode_item({array, int, Name}, TypeList);
+	_ -> 
+	    TypeString = get_csharp_type(Type),
+	    NameStr = get_csharp_Var(Name),
+	    CountString = "countOf" ++ NameStr,
+	    _ArrayString = "arrayOf" ++ NameStr,
+	    "        local " ++ CountString ++ " = byteArray.read_uint16()\n" ++
+	    "        tb."++NameStr++" = {}\n" ++
+    	    "        for i = 1, " ++ CountString ++ " do\n" ++
+            "            local temp = " ++ TypeString ++ "()\n" ++
+    	    "            temp.decode(byteArray)\n" ++ 
+    	    "            table.insert(tb."++NameStr++", temp)\n" ++ 
+            "        end\n"
+    end.
+
+make_protocal_encode_item_decode_type(Name, Type) ->
+    NameStr = get_csharp_Var(Name),
+    TypeStr = atom_to_list(Type),
+    CountString = "countOf" ++ NameStr,
+    "        local " ++ CountString ++ " = byteArray.read_uint16()\n" ++
+    "        tb."++NameStr++" = {}\n" ++
+    "        for i = 1, " ++ CountString ++ " do\n" ++
+    "             table.insert(tb." ++ NameStr ++ ", byteArray.read_" ++ TypeStr ++ "())\n" ++
+    "        end\n".
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成网络类型%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+make_protocal_msg_type([], MsgTypeStr, _Index) ->
+    "NetMsgType = \n" ++ 
+    "{\n" ++
+    MsgTypeStr ++ 
+    "}";
+make_protocal_msg_type([Struct|Structs], MsgTypeStr, Index) ->
+    [StructName | _NewStructList] = Struct,
+    case Structs == [] of 
+	true ->
+	    make_protocal_msg_type(Structs, MsgTypeStr ++ "    [\"msg_" ++ atom_to_list(StructName) ++ "\"] = "++integer_to_list(Index)++"\n", Index+1);
+	false ->
+	    make_protocal_msg_type(Structs, MsgTypeStr ++ "    [\"msg_" ++ atom_to_list(StructName) ++ "\"] = "++integer_to_list(Index)++",\n", Index+1)
+    end.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%生成枚举类型%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+make_protocal_const(Ver) ->
+    "function get_proto_version()
+
+    return "++integer_to_list(Ver)++";
+end\n".
+
+make_protocal_enum([], EnumStr) ->
+    EnumStr;
+make_protocal_enum([Enum | Enums], EnumStr) ->
+    {EnumName , EnumItems} = Enum,
+    EnumStr1 = EnumStr  ++
+	string:to_lower(atom_to_list(EnumName)) ++ " = \n{\n" ++ 
+	make_protocal_enum_item(EnumItems, 1, "") ++ "}\n",
+    make_protocal_enum(Enums, EnumStr1).
+
+make_protocal_enum_item([EnumItem | []], Index, EnumItemStr) ->
+    EnumItemStr ++ "    [\"" ++ atom_to_list(EnumItem) ++ "\"] = "++integer_to_list(Index)++"\n";
+make_protocal_enum_item([EnumItem | EnumItems], Index, EnumItemStr) ->
+    EnumItemStr1 = EnumItemStr ++ "    [\"" ++ atom_to_list(EnumItem) ++ "\"]= "++integer_to_list(Index)++",\n",
+    make_protocal_enum_item(EnumItems, Index + 1, EnumItemStr1).
+
+get_csharp_Var(Type)->
+    TypeString = atom_to_list(Type),
+    case lists:keyfind(TypeString, 1, get_keyword_mapping()) of
+	{TypeString, CSharpTypeString}->
+	    CSharpTypeString;
+	_ ->
+	    TypeString
+    end.
+get_csharp_type(Type) -> 
+    TypeString = atom_to_list(Type),
+    case lists:keyfind(TypeString, 1, get_cshapr_type_mapping()) of
+	{TypeString, CSharpTypeString}->
+	    CSharpTypeString;
+	_ ->
+	    TypeString
+    end.
+
+get_cshapr_type_mapping()->
+    [
+     {"uint", "UInt"},
+     {"int16", "Int16"}, 
+     {"uint16", "UInt16"}, 
+     {"int64", "Int64"}, 
+     {"uint64", "uint64"}, 
+     {"uchar", "char"} 
+    ].
+
+get_keyword_mapping() ->
+    [
+     {"lock", "Lock"},
+     {"params", "Params"}
+    ].
+
+make_getmsgid(StructName)->
+    	"    tb.getMsgID = function()\n" ++
+	"    " ++
+        "    return NetMsgType[\"msg_" ++ atom_to_list(StructName) ++ "\"]\n" ++
+        "    end\n".
+
+get_default_value(Type, DefaultValue)
+  when (Type == int orelse 
+	Type == uint orelse
+	Type == uint64 orelse
+	Type == uint16 orelse
+	Type == int64 orelse
+	Type == short orelse
+	Type == int16)
+       andalso  is_integer(DefaultValue)->
+    integer_to_list(DefaultValue);
+get_default_value(Type, DefaultValue)
+  when (Type == float orelse 
+	Type == long orelse
+	Type == double orelse
+	Type == uint16 orelse
+	Type == int64 orelse
+	Type == int16)
+       andalso is_float(DefaultValue)->
+    float_to_list(DefaultValue);
+get_default_value(char, DefaultValue) 
+  when is_list(DefaultValue)->
+    "'" ++ DefaultValue ++ "'";
+get_default_value(string, DefaultValue)
+  when is_atom(DefaultValue)->
+    get_default_value(string, atom_to_list(DefaultValue));
+get_default_value(string, DefaultValue) 
+  when is_list(DefaultValue)->
+    "\"" ++ DefaultValue ++ "\"".
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%测试函数%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+test() ->
+    %% 	test_make_protocal_encode_item(),
+    %% 	test_make_protocal_decode_item(),
+    %% 	test_make_protocal_encode(),
+    %% 	test_make_protocal_decode().
+    start().
+
+%% test_make_protocal_encode_item() ->
+%% 	"\t\tbyteArray.write_uint16(result.size());\n\t\tfor(int i=0; i<result.size();i++)\n\t{\n\t\t\tresult[i].encode(byteArray);\n\t}\n"
+%% 		= make_protocal_encode_item({array, notify_login_result, result}, gen_common:get_type()),
+%% 	"\t\tbyteArray.write_uint16(account.size());\n\t\tfor(int i=0; i<account.size();i++)\n\t{\n\t\t\tbyteArray.write_string(account[i]);\n\t}\n" 
+%% 		= make_protocal_encode_item({array, string, account}, gen_common:get_type()),
+%% 	"\t\tbyteArray.write_uint16(account.size());\n\t\tfor(int i=0; i<account.size();i++)\n\t{\n\t\t\tbyteArray.write_int(account[i]);\n\t}\n" 
+%% 		= make_protocal_encode_item({array, login_result, account}, gen_common:get_type()),
+%% 	"\t\tbyteArray.write_string(account);\n" = make_protocal_encode_item({string, account}, gen_common:get_type()),
+%% 	"\t\tbyteArray.write_int(account);\n" = make_protocal_encode_item({login_result, account}, gen_common:get_type()),
+%% 	"\t\taccount.encode(byteArray);\n" = make_protocal_encode_item({notify_login_result, account}, gen_common:get_type()).
+%% 
+%% test_make_protocal_decode_item() ->
+%% 	"uint16 size = byteArray.read_uint16();\naccount.reserve(size);\nfor(int i=0; i<size;i++)\n{\n\taccount.push_back(byteArray.read_string());\n}\n"
+%% 		= make_protocal_decode_item({array, string, account}, gen_common:get_type()),
+%% 	"uint16 size = byteArray.read_uint16();\nresult.resize(size);\nfor(int i=0; i<size;i++)\n{\n\tresult[i].decode(byteArray);\n}\n"
+%% 		= make_protocal_decode_item({array, notify_login_result, result}, gen_common:get_type()),
+%% 	"uint16 size = byteArray.read_uint16();\naccount.reserve(size);\nfor(int i=0; i<size;i++)\n{\n\taccount.push_back(byteArray.read_int());\n}\n"
+%% 		= make_protocal_decode_item({array, login_result, account}, gen_common:get_type()),
+%% 	"account = byteArray.read_string();\n" = make_protocal_decode_item({string, account}, gen_common:get_type()),
+%% 	"account = byteArray.read_int();\n" = make_protocal_decode_item({login_result, account}, gen_common:get_type()),
+%% 	"account.decode(byteArray);\n" = make_protocal_decode_item({notify_login_result, account}, gen_common:get_type()).
+%% 
+%% test_make_protocal_encode() ->
+%% 	Result = make_protocal_encode([{array, string, account},
+%% 		 	{string, pwd},
+%% 		 	{player_data, data},
+%% 		 	{array, notify_login_result, result}], "", gen_common:get_type()),
+%% 	io:format("~p~n", [Result]).
+%% 
+%% test_make_protocal_decode() ->
+%% 	Result = make_protocal_decode([{array, string, account},
+%% 		 	{string, pwd},
+%% 		 	{player_data, data},
+%% 		 	{array, notify_login_result, result}], "", gen_common:get_type()),
+%% 	io:format("~p~n", [Result]).
+%% 
+%% test_make_protocal_Variable() ->
+%% 	Result = make_protocal_Variable([{array, string, account},
+%% 		 	{string, pwd},
+%% 		 	{player_data, data},
+%% 		 	{array, notify_login_result, result}], "", gen_common:get_type()),
+%% 	io:format("~p~n", [Result]).

src/writeLua/reader.lua

@@ -1,189 +0,0 @@
----Read dynamic size
----@param b string @buffer.
----@param p number @buffer pointer.
----@return number, number
-local function type_dsize(b, p)
-	local bb = string.byte(b, p)
-	p = p + 1
-	n = (bb&0XC0)>>6
-	s = (bb&0X3F)
-	while n > 0 do
-		bb = string.byte(b, p)
-		p = p + 1
-		s = (s<<8)|bb
-		n = n - 1
-	end
-	return s, p
-end
-
----Read int64 as 8 byte string
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_int64(b, p)
-	return string.unpack("<i8", b, p)
-end
-
----Read uint64 as 8 byte string
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_uint64(b, p)
-	return string.unpack("<I8", b, p)
-end
-
----Read double
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_double(b, p)
-	return string.unpack("<d", b, p)
-end
-
----Read float
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_float(b, p)
-	return string.unpack("<f", b, p)
-end
-
----Read int32
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_int32(b, p)
-	return string.unpack("<i4", b, p)
-end
-
----Read uint32
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_uint32(b, p)
-	return string.unpack("<I4", b, p)
-end
-
----Read int32
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_int16(b, p)
-	return string.unpack("<i2", b, p)
-end
-
----Read uint16
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_uint16(b, p)
-	return string.unpack("<I2", b, p)
-end
-
----Read int8
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_int8(b, p)
-	return string.unpack("<b", b, p)
-end
-
----Read uint8
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_uint8(b, p)
-	return string.unpack("<B", b, p)
-end
-
----Read bool
----@param b string @buffer
----@param p number @buffer pointer.
----@return boolean, number
-local function type_bool(b, p)
-	local r
-	r, p = string.unpack("<B", b, p)
-	if r == 0 then
-		return false, p
-	else
-		return true, p
-	end
-end
-
----Read string
----@param b string @buffer
----@param p number @buffer pointer.
----@param valMax number @max value.
----@return string, number
-local function type_string(b, p, valMax)
-	local l
-	l, p = type_dsize(b, p)
-	if valMax and l > valMax then
-		error("Invalid string length")
-	end
-	local r = string.sub(b, p, p+l-1)
-	return r, p+l
-end
-
----Read enum
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_enum(b, p)
-	return type_uint8(b, p, 0)
-end
-
----Read enum16
----@param b string @buffer
----@param p number @buffer pointer.
----@return number, number
-local function type_enum16(b, p)
-	return type_uint16(b, p)
-end
-
----Read binary
----@param b string @buffer
----@param p number @buffer pointer.
----@param valMax number @max value.
----@return string, number
-local function type_binary(b, p, valMax)
-	return type_string(b, p, valMax)
-end
-
-local function type_array(b, p, t, arrMax, valMax)
-	local l
-	l, p = type_dsize(b, p)
-	if l > arrMax then
-		error("Invalid array length")
-	else
-		local arr = {}
-		for i = 1, l do
-			local r
-			r, p = t(b, p, valMax)
-			arr[i] = r
-		end
-		return arr, p
-	end
-end
-
-BintalkReader = 
-{
-	int64	= type_int64,
-	uint64 = type_uint64,
-	double = type_double,
-	float	= type_float,
-	int32	= type_int32,
-	uint32 = type_uint32,
-	int16	= type_int16,
-	uint16 = type_uint16,
-	int8	= type_int8,
-	uint8	= type_uint8,
-	bool	= type_bool,
-	string	= type_string,
-	binary	= type_binary,
-	enum	= type_enum,
-	enum16	= type_enum16,
-
-	array	= type_array,
-}

src/writeLua/types.lua

@@ -1,111 +0,0 @@
----Construct number.
----@param v number
----@return number
-local function type_number(v)
-    if not v then return 0 end
-    assert(type(v) == "number")
-    return v 
-end
-
----Construct boolean
----@param v boolean
----@return boolean
-local function type_boolean(v)
-    if not v then return false end
-    assert(type(v) == "boolean")
-    return v 
-end
-
----Construct string
----@param v string
----@return string
-local function type_string(v)
-    if not v then return "" end
-    assert(type(v) == "string")
-    return v 
-end
-
----Construct array
----@param t any @inner type
----@param v table
-local function type_array(t, v)
-    if not v then return {} end
-    assert(type(v) == "table")
-    local array = {}
-    for i,item in ipairs(v) do
-        table.insert(array, t(item))
-    end
-    return array 
-end
-
----Enum metatable.
-local enum_mt = {}
-function enum_mt.__index(t, k)
-    local v = t._enum[k]
-    if v == nil then
-        error("Attempt to get invalid enum item:"..k)
-    end
-    return v
-end
-function enum_mt.__newindex(t, k, v)
-    error("Attempt to modify enum item:"..k)
-end
-function enum_mt.__call(t)
-    return 0
-end
-function enum_mt.__pairs(t)
-    local function iter(t, k)
-        local v
-        k, v = next(t._enum, k)
-        if v then
-            return k,v
-        end
-    end
-    return iter, t._enum, nil
-end
-
----User type metatable.
-local struct_mt = {}
-function struct_mt.__index(t, k)
-    -- Get default value.
-    local dv = t._defaults[k]
-    if dv == nil then
-        error("Attempt to get invalid struct field:"..k)
-    end
-    -- Get value.
-    return rawget(t._values, k)
-end
-function struct_mt.__newindex(t, k, v)
-    -- Get default value.
-    local dv = t._defaults[k]
-    if dv == nil then
-        error("Attempt to set invalid struct field:"..k)
-    end
-    if type(dv) ~= type(v) then
-        error("Attempt to set struct field with invalid value type:"..k.." "..type(v))
-    end
-    rawset(t._values, k, v)
-end
-
-BintalkTypes = {
-    int64	= type_number,
-    uint64 = type_number,
-    double = type_number,
-    float	= type_number,
-	int32	= type_number,
-    uint32 = type_number,
-    int16	= type_number,
-    uint16 = type_number,
-    int8	= type_number,
-    uint8	= type_number,
-    bool	= type_boolean,
-    string	= type_string,
-    binary	= type_string,
-    enum	= type_number,
-    enum16	= type_number,
-
-    array	= type_array,
-
-    _enum_mt = enum_mt,
-    _struct_mt = struct_mt,
-}

src/writeLua/writer.lua

@@ -1,170 +0,0 @@
----Write dynamic size
----@param v number @size
----@param b string[] @buffer.
-local function type_dsize(v, b)
-	if v <= 0X3F then
-		b[#b+1] = string.char(v)
-	elseif v <= 0X3FFF then
-		v = v | (1<<14)
-		local v1 = (v & 0XFF00)>>8
-		local v2 = (v & 0XFF)
-		b[#b+1] = string.char(v1, v2)
-	elseif v <= 0X3FFFFF then
-		v = v | (2<<22)
-		local v1 = (v & 0XFF0000)>>16
-		local v2 = (v & 0XFF00)>>8
-		local v3 = (v & 0XFF)
-		b[#b+1] = string.char(v1, v2, v3)
-	elseif v <= 0X3FFFFFFF then
-		v = v | (3<<30)
-		local v1 = (v & 0XFF000000)>>24
-		local v2 = (v & 0XFF0000)>>16
-		local v3 = (v & 0XFF00)>>8
-		local v4 = (v & 0XFF)
-		b[#b+1] = string.char(v1, v2, v3, v4)
-	else
-		error("Invalid dynamic size")
-	end
-end
-
----@param v number @value
----@param b string[] @buffer.
-local function type_int64(v, b)
-	b[#b+1] = string.pack("<i8", v)
-end
-
----@param v number @value
----@param b string[] @buffer.
-local function type_uint64(v, b)
-	b[#b+1] = string.pack("<I8", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_double(v, b)
-	b[#b+1] = string.pack("<d", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_float(v, b)
-	b[#b+1] = string.pack("<f", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_int32(v, b)
-	b[#b+1] = string.pack("<i4", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_uint32(v, b)
-	b[#b+1] = string.pack("<I4", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_int16(v, b)
-	b[#b+1] = string.pack("<i2", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_uint16(v, b)
-	b[#b+1] = string.pack("<I2", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_int8(v, b)
-	b[#b+1] = string.pack("<b", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_uint8(v, b)
-	b[#b+1] = string.pack("<B", v)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_bool(v, b)
-	b[#b+1] = string.pack("<B", (v and 1 or 0))
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_string(v, b)
-	assert(type(v) == "string")
-	type_dsize(#v, b)
-	b[#b+1] = v
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_enum(v, b)
-	type_uint8(v, b)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_enum16(v, b)
-	type_uint16(v, b)
-end
-
----@param v number @size
----@param b string[] @buffer.
-local function type_binary(v, b)
-	assert(type(v) == "string")
-	type_dsize(#v, b)
-	b[#b+1] = v
-end
-
----@param t fun()
----@param v number @size
----@param b string[] @buffer.
-local function type_array(t, v, b)
-	assert(type(v) == "table")
-	type_dsize(#v, b)
-	for i = 1, #v do
-		t(v[i], b)
-	end
-end
-
-BintalkWriter = 
-{
-	int64	= type_int64,
-	uint64 = type_uint64,
-	double = type_double,
-	float	= type_float,
-	int32	= type_int32,
-	uint32 = type_uint32,
-	int16	= type_int16,
-	uint16 = type_uint16,
-	int8	= type_int8,
-	uint8	= type_uint8,
-	bool	= type_bool,
-	string	= type_string,
-	binary	= type_binary,
-	enum	= type_enum,
-	enum16	= type_enum16,
-
-	array	= type_array,
-}