From 8f87f1b060e5af64364ac338db6c52553f535e14 Mon Sep 17 00:00:00 2001 From: SisMaker <1713699517@qq.com> Date: Fri, 9 Apr 2021 21:44:30 +0800 Subject: [PATCH] =?UTF-8?q?ft:=20lua=20cs=E7=A4=BA=E4=BE=8B=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=E6=B7=BB=E5=8A=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- proto/Example.btk | 106 ++++++ src/writeCs/CSGenerator.cpp | 214 +++++++++++ src/writeCs/IReader.cs | 13 + src/writeCs/IWriter.cs | 9 + src/writeCs/ProtocolReader.cs | 148 ++++++++ src/writeCs/ProtocolWriter.cs | 113 ++++++ src/writeCs/testExample.cs | 676 ++++++++++++++++++++++++++++++++++ src/writeLua/Example.lua | 562 ++++++++++++++++++++++++++++ src/writeLua/LUAGenerator.cpp | 161 ++++++++ src/writeLua/reader.lua | 189 ++++++++++ src/writeLua/types.lua | 111 ++++++ src/writeLua/writer.lua | 170 +++++++++ 12 files changed, 2472 insertions(+) create mode 100644 proto/Example.btk create mode 100644 src/writeCs/CSGenerator.cpp create mode 100644 src/writeCs/IReader.cs create mode 100644 src/writeCs/IWriter.cs create mode 100644 src/writeCs/ProtocolReader.cs create mode 100644 src/writeCs/ProtocolWriter.cs create mode 100644 src/writeCs/testExample.cs create mode 100644 src/writeLua/Example.lua create mode 100644 src/writeLua/LUAGenerator.cpp create mode 100644 src/writeLua/reader.lua create mode 100644 src/writeLua/types.lua create mode 100644 src/writeLua/writer.lua diff --git a/proto/Example.btk b/proto/Example.btk new file mode 100644 index 0000000..9a1dbc7 --- /dev/null +++ b/proto/Example.btk @@ -0,0 +1,106 @@ +// 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_; +} diff --git a/src/writeCs/CSGenerator.cpp b/src/writeCs/CSGenerator.cpp new file mode 100644 index 0000000..87a7b09 --- /dev/null +++ b/src/writeCs/CSGenerator.cpp @@ -0,0 +1,214 @@ +#include "Options.h" +#include "Context.h" +#include "CodeFile.h" + +#include "CodeGenerator.h" +DECLARE_CG(CSGenerator, cs); + +static void generateEnum(CodeFile& f, Enum* e) +{ + f.output("public enum %s : %s", e->getNameC(), e->isEnum16()?"ushort":"byte"); + f.indent("{"); + for(size_t i = 0; i < e->items_.size(); i++) + f.output("%s,", e->items_[i].c_str()); + f.recover("}"); + + f.output("namespace bintalk"); + f.indent("{"); + f.output("public static partial class ProtocolReader"); + f.indent("{"); + f.output("public static bool read(bintalk.IReader r, ref %s v, uint maxValue)", e->getNameC()); + f.indent("{"); + f.output("%s e = 0;", e->isEnum16()?"ushort":"byte"); + f.output("if(!read(r, ref e, 0)) return false;"); + f.output("v = (%s)e;", e->getNameC()); + f.output("return true;"); + f.recover("}"); + f.recover("}"); + f.output("public static partial class ProtocolWriter"); + f.indent("{"); + f.output("public static void write(bintalk.IWriter w, %s v)", e->getNameC()); + f.indent("{"); + f.output("write(w, (%s)v);", e->isEnum16()?"ushort":"byte"); + f.recover("}"); + f.recover("}"); + f.recover("}"); +} + +static const char* getFieldInnerTypeName(Field& f) +{ + switch(f.type_) + { + case Field::FT_INT64: return "long"; + case Field::FT_UINT64: return "ulong"; + case Field::FT_DOUBLE: return "double"; + case Field::FT_FLOAT: return "float"; + case Field::FT_INT32: return "int"; + case Field::FT_UINT32: return "uint"; + case Field::FT_INT16: return "short"; + case Field::FT_UINT16: return "ushort"; + case Field::FT_INT8: return "sbyte"; + case Field::FT_UINT8: return "byte"; + case Field::FT_BOOL: return "bool"; + case Field::FT_STRING: return "string"; + case Field::FT_BINARY: return "byte[]"; + case Field::FT_USER: + case Field::FT_ENUM: return f.userType_->getNameC(); + } + return NULL; +} + +static void getFieldTypeName(Field& f, std::string& name) +{ + name = getFieldInnerTypeName(f); + if(f.isArray()) + name = "List<" + name + ">"; +} + +static void getFieldInnerDefault(Field& f, std::string& name) +{ + switch(f.type_) + { + case Field::FT_INT64: + case Field::FT_UINT64: + case Field::FT_DOUBLE: + case Field::FT_FLOAT: + case Field::FT_INT32: + case Field::FT_UINT32: + case Field::FT_INT16: + case Field::FT_UINT16: + case Field::FT_INT8: + case Field::FT_UINT8: name = "0"; break; + case Field::FT_BOOL: name = "false"; break; + case Field::FT_STRING: name = "\"\""; break; + case Field::FT_BINARY: name = "new byte[0]"; break; + case Field::FT_USER: name = "new "; name += f.userType_->name_; name += "()"; break; + case Field::FT_ENUM: name = "("; name += f.userType_->name_; name += ")(0)"; break; + } +} +static void getFieldDefault(Field& f, std::string& name) +{ + if(f.isArray()) + { + name = "new "; + std::string tn; + getFieldTypeName(f, tn); + name += tn; + name += "()"; + } + else + getFieldInnerDefault(f, name); +} + +static void generateFieldSCode(CodeFile& f, Field& field) +{ + if(field.isArray()) + { + f.indent("{"); + f.output("bintalk.ProtocolWriter.writeDynSize(__w__, (uint)%s.Count);", field.getNameC()); + f.output("foreach(%s __vi__ in %s) bintalk.ProtocolWriter.write(__w__, __vi__);", + getFieldInnerTypeName(field), + field.getNameC()); + f.recover("}"); + } + else + f.output("bintalk.ProtocolWriter.write(__w__, %s);", field.getNameC()); +} + +static void generateFieldContainerSCode(CodeFile& f, FieldContainer* fc) +{ + for(size_t i = 0; i < fc->fields_.size(); i++) + generateFieldSCode(f, fc->fields_[i]); +} + +static void generateFieldDSCode(CodeFile& f, Field& field) +{ + if(field.isArray()) + { + f.indent("{"); + f.output("uint __s__;"); + f.output("if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0X%X) return false;", field.maxArray_); + f.output("for(uint __i__ = 0; __i__ < __s__; __i__++)"); + f.indent("{"); + std::string idft; + getFieldInnerDefault(field, idft); + f.output("%s __vi__ = %s;", getFieldInnerTypeName(field), idft.c_str()); + f.output("if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X%X)) return false;", field.maxValue_); + f.output("%s.Add(__vi__);", field.getNameC()); + f.recover("}"); + f.recover("}"); + } + else + f.output("if(!bintalk.ProtocolReader.read(__r__, ref %s, 0X%X)) return false;", field.getNameC(), field.maxValue_); +} + +static void generateFieldContainerDSCode(CodeFile& f, FieldContainer* fc) +{ + for(size_t i = 0; i < fc->fields_.size(); i++) + generateFieldDSCode(f, fc->fields_[i]); +} + +static void generateStruct(CodeFile& f, Struct* s) +{ + f.output("public class %s", s->getNameC()); + f.indent("{"); + // fields. + for(size_t i = 0; i < s->fields_.size(); i++) + { + Field& field = s->fields_[i]; + std::string tn; + getFieldTypeName(field, tn); + std::string dft; + getFieldDefault(field, dft); + f.output("public %s %s= %s;", + tn.c_str(), + field.getNameC(), + dft.c_str()); + } + // serialize code. + f.output("public void serialize(bintalk.IWriter __w__)"); + f.indent("{"); + generateFieldContainerSCode(f, s); + f.recover("}"); + // deserialize code. + f.output("public bool deserialize(bintalk.IReader __r__)"); + f.indent("{"); + generateFieldContainerDSCode(f, s); + f.output("return true;"); + f.recover("}"); + f.recover("}"); + //////////////////////////////////////////////////////////////////////////////// + f.output("namespace bintalk"); + f.indent("{"); + f.output("public static partial class ProtocolReader"); + f.indent("{"); + f.output("public static bool read(bintalk.IReader r, ref %s v, uint maxValue)", s->getNameC()); + f.indent("{"); + f.output("return v.deserialize(r);"); + f.recover("}"); + f.recover("}"); + f.output("public static partial class ProtocolWriter"); + f.indent("{"); + f.output("public static void write(bintalk.IWriter w, %s v)", s->getNameC()); + f.indent("{"); + f.output("v.serialize(w);"); + f.recover("}"); + f.recover("}"); + f.recover("}"); +} + +void CSGenerator::generate() +{ + CodeFile f(gOptions.output_ + gOptions.inputFS_ + ".cs"); + f.output("using System.Collections.Generic;"); + 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()); + } +} diff --git a/src/writeCs/IReader.cs b/src/writeCs/IReader.cs new file mode 100644 index 0000000..b889318 --- /dev/null +++ b/src/writeCs/IReader.cs @@ -0,0 +1,13 @@ +namespace bintalk +{ + /** Abstract interface for reading binary data. */ + public interface IReader + { + /** + * @param size data size want to read. + * @param[out] data buffer. + * @param[out] data buffer start id. + */ + bool read(uint size, out byte[] data, out int startId); + } +} diff --git a/src/writeCs/IWriter.cs b/src/writeCs/IWriter.cs new file mode 100644 index 0000000..f706db2 --- /dev/null +++ b/src/writeCs/IWriter.cs @@ -0,0 +1,9 @@ +namespace bintalk +{ + /** Abstract interface for writing binary data. */ + public interface IWriter + { + /** Write some binary data. */ + void write(byte[] data); + } +} diff --git a/src/writeCs/ProtocolReader.cs b/src/writeCs/ProtocolReader.cs new file mode 100644 index 0000000..11436ce --- /dev/null +++ b/src/writeCs/ProtocolReader.cs @@ -0,0 +1,148 @@ +using System; +using System.Text; +using System.Collections.Generic; + +namespace bintalk +{ + /** This class can read basic types by using a bintalk.IReader object. */ + public static partial class ProtocolReader + { + public static bool readMid(bintalk.IReader r, ref ushort v) + { + return read(r, ref v, 0); + } + // int64 + public static bool read(bintalk.IReader r, ref long v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(8, out data, out startId)) return false; + v = BitConverter.ToInt64(data, startId); + return true; + } + // uint64 + public static bool read(bintalk.IReader r, ref ulong v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(8, out data, out startId)) return false; + v = BitConverter.ToUInt64(data, startId); + return true; + } + // double + public static bool read(bintalk.IReader r, ref double v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(8, out data, out startId)) return false; + v = BitConverter.ToDouble(data, startId); + return true; + } + // float + public static bool read(bintalk.IReader r, ref float v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(4, out data, out startId)) return false; + v = BitConverter.ToSingle(data, startId); + return true; + } + // int32 + public static bool read(bintalk.IReader r, ref int v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(4, out data, out startId)) return false; + v = BitConverter.ToInt32(data, startId); + return true; + } + // uint32 + public static bool read(bintalk.IReader r, ref uint v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(4, out data, out startId)) return false; + v = BitConverter.ToUInt32(data, startId); + return true; + } + // int16 + public static bool read(bintalk.IReader r, ref short v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(2, out data, out startId)) return false; + v = BitConverter.ToInt16(data, startId); + return true; + } + // uint16 + public static bool read(bintalk.IReader r, ref ushort v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(2, out data, out startId)) return false; + v = BitConverter.ToUInt16(data, startId); + return true; + } + // int8 + public static bool read(bintalk.IReader r, ref sbyte v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(1, out data, out startId)) + return false; + v = (sbyte)data[startId]; + return true; + } + // uint8 + public static bool read(bintalk.IReader r, ref byte v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(1, out data, out startId)) + return false; + v = data[startId]; + return true; + } + // bool + public static bool read(bintalk.IReader r, ref bool v, uint maxValue) + { + byte[] data; int startId; + if (!r.read(1, out data, out startId)) + return false; + v = (data[startId] == 0)?false:true; + return true; + } + // string. + public static bool read(bintalk.IReader r, ref string v, uint maxValue) + { + uint s; + if (!readDynSize(r, out s) || s > maxValue) + return false; + byte[] data; int startId; + if(!r.read(s, out data, out startId)) + return false; + v = Encoding.UTF8.GetString(data, startId, (int)s); + return true; + } + // binary. + public static bool read(bintalk.IReader r, ref byte[] v, uint maxValue) + { + uint s; + if (!readDynSize(r, out s) || s > maxValue) + return false; + v = new byte[s]; + byte[] data; int startId; + if(!r.read(s, out data, out startId)) + return false; + Array.Copy(data, startId, v, 0, s); + return true; + } + // dynamic size. + public static bool readDynSize(bintalk.IReader r, out uint s) + { + s = 0; + byte b = 0; + if (!read(r, ref b, 0)) + return false; + uint n = (uint)((b & 0XC0) >> 6); + s = (uint)(b & 0X3F); + for (int i = 0; i < n; i++) + { + if (!read(r, ref b, 0)) + return false; + s = (s << 8) | b; + } + return true; + } + } +} diff --git a/src/writeCs/ProtocolWriter.cs b/src/writeCs/ProtocolWriter.cs new file mode 100644 index 0000000..9c7daf0 --- /dev/null +++ b/src/writeCs/ProtocolWriter.cs @@ -0,0 +1,113 @@ +using System; +using System.Text; +using System.Collections.Generic; + +namespace bintalk +{ + /** This class can write basic types by using a bintalk.IWriter object. */ + public static partial class ProtocolWriter + { + public static void writeMid(bintalk.IWriter w, int v) + { + write(w, (ushort)v); + } + // int 64 + public static void write(bintalk.IWriter w, long v) + { + w.write(BitConverter.GetBytes(v)); + } + // uint64 + public static void write(bintalk.IWriter w, ulong v) + { + w.write(BitConverter.GetBytes(v)); + } + // double + public static void write(bintalk.IWriter w, double v) + { + w.write(BitConverter.GetBytes(v)); + } + // float + public static void write(bintalk.IWriter w, float v) + { + w.write(BitConverter.GetBytes(v)); + } + // int32 + public static void write(bintalk.IWriter w, int v) + { + w.write(BitConverter.GetBytes(v)); + } + // uint32 + public static void write(bintalk.IWriter w, uint v) + { + w.write(BitConverter.GetBytes(v)); + } + // int16 + public static void write(bintalk.IWriter w, short v) + { + w.write(BitConverter.GetBytes(v)); + } + // uint16 + public static void write(bintalk.IWriter w, ushort v) + { + w.write(BitConverter.GetBytes(v)); + } + // int8 + public static void write(bintalk.IWriter w, sbyte v) + { + w.write(new byte[1]{(byte)v}); + } + // uint8 + public static void write(bintalk.IWriter w, byte v) + { + w.write(new byte[1]{v}); + } + // bool + public static void write(bintalk.IWriter w, bool v) + { + write(w, (byte)(v?1:0)); + } + // string + public static void write(bintalk.IWriter w, string v) + { + if (v == null || v.Length == 0) + writeDynSize(w, 0); + else + { + byte[] str = Encoding.UTF8.GetBytes(v); + uint len = (uint)str.Length; + writeDynSize(w, len); + if (len > 0) + w.write(str); + } + } + // binary. + public static void write(bintalk.IWriter w, byte[] v) + { + if (v == null || v.Length == 0) + writeDynSize(w, 0); + else + { + uint s = (uint)v.Length; + writeDynSize(w, s); + w.write(v); + } + } + // dynamic size. + public static void writeDynSize(bintalk.IWriter w, uint s) + { + byte[] b = BitConverter.GetBytes(s); + int n = 0; + if (s <= 0X3F) + n = 0; + else if (s <= 0X3FFF) + n = 1; + else if(s <= 0X3FFFFF) + n = 2; + else if(s <= 0X3FFFFFFF) + n = 3; + b[n] |= (byte)(n << 6); + for(int i = n; i >= 0; i--) + write(w, b[i]); + } + } +} diff --git a/src/writeCs/testExample.cs b/src/writeCs/testExample.cs new file mode 100644 index 0000000..dc83769 --- /dev/null +++ b/src/writeCs/testExample.cs @@ -0,0 +1,676 @@ +using System.Collections.Generic; +public enum EnumName : byte +{ + EN1, + EN2, + EN3, +} +namespace bintalk +{ + public static partial class ProtocolReader + { + public static bool read(bintalk.IReader r, ref EnumName v, uint maxValue) + { + byte e = 0; + if(!read(r, ref e, 0)) return false; + v = (EnumName)e; + return true; + } + } + public static partial class ProtocolWriter + { + public static void write(bintalk.IWriter w, EnumName v) + { + write(w, (byte)v); + } + } +} +public enum EnumName16 : ushort +{ + 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, +} +namespace bintalk +{ + public static partial class ProtocolReader + { + public static bool read(bintalk.IReader r, ref EnumName16 v, uint maxValue) + { + ushort e = 0; + if(!read(r, ref e, 0)) return false; + v = (EnumName16)e; + return true; + } + } + public static partial class ProtocolWriter + { + public static void write(bintalk.IWriter w, EnumName16 v) + { + write(w, (ushort)v); + } + } +} +public class StructType +{ + public string aaa_= ""; + public int bbb_= 0; + public void serialize(bintalk.IWriter __w__) + { + bintalk.ProtocolWriter.write(__w__, aaa_); + bintalk.ProtocolWriter.write(__w__, bbb_); + } + public bool deserialize(bintalk.IReader __r__) + { + if(!bintalk.ProtocolReader.read(__r__, ref aaa_, 0XFFFFFFFF)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref bbb_, 0X0)) return false; + return true; + } +} +namespace bintalk +{ + public static partial class ProtocolReader + { + public static bool read(bintalk.IReader r, ref StructType v, uint maxValue) + { + return v.deserialize(r); + } + } + public static partial class ProtocolWriter + { + public static void write(bintalk.IWriter w, StructType v) + { + v.serialize(w); + } + } +} +public class StructBase +{ + public double double_= 0; + public float float_= 0; + public long int64_= 0; + public ulong uint64_= 0; + public int int32_= 0; + public uint uint32_= 0; + public short int16_= 0; + public ushort uint16_= 0; + public sbyte int8_= 0; + public byte uint8_= 0; + public bool bool_= false; + public EnumName enum_= (EnumName)(0); + public EnumName16 enum16_= (EnumName16)(0); + public StructType struct_= new StructType(); + public string string_= ""; + public string string1_= ""; + public byte[] bin_= new byte[0]; + public byte[] bin1_= new byte[0]; + public List doubleArray_= new List(); + public List floatArray_= new List(); + public List int64Array_= new List(); + public List uint64Array_= new List(); + public List int32Array_= new List(); + public List uint32Array_= new List(); + public List int16Array_= new List(); + public List uint16Array_= new List(); + public List int8Array_= new List(); + public List uint8Array_= new List(); + public List boolArray_= new List(); + public List strArray_= new List(); + public List strArray1_= new List(); + public List binArray_= new List(); + public List bin1Array_= new List(); + public List enumArray_= new List(); + public List structArray_= new List(); + public void serialize(bintalk.IWriter __w__) + { + bintalk.ProtocolWriter.write(__w__, double_); + bintalk.ProtocolWriter.write(__w__, float_); + bintalk.ProtocolWriter.write(__w__, int64_); + bintalk.ProtocolWriter.write(__w__, uint64_); + bintalk.ProtocolWriter.write(__w__, int32_); + bintalk.ProtocolWriter.write(__w__, uint32_); + bintalk.ProtocolWriter.write(__w__, int16_); + bintalk.ProtocolWriter.write(__w__, uint16_); + bintalk.ProtocolWriter.write(__w__, int8_); + bintalk.ProtocolWriter.write(__w__, uint8_); + bintalk.ProtocolWriter.write(__w__, bool_); + bintalk.ProtocolWriter.write(__w__, enum_); + bintalk.ProtocolWriter.write(__w__, enum16_); + bintalk.ProtocolWriter.write(__w__, struct_); + bintalk.ProtocolWriter.write(__w__, string_); + bintalk.ProtocolWriter.write(__w__, string1_); + bintalk.ProtocolWriter.write(__w__, bin_); + bintalk.ProtocolWriter.write(__w__, bin1_); + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)doubleArray_.Count); + foreach(double __vi__ in doubleArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)floatArray_.Count); + foreach(float __vi__ in floatArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)int64Array_.Count); + foreach(long __vi__ in int64Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)uint64Array_.Count); + foreach(ulong __vi__ in uint64Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)int32Array_.Count); + foreach(int __vi__ in int32Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)uint32Array_.Count); + foreach(uint __vi__ in uint32Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)int16Array_.Count); + foreach(short __vi__ in int16Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)uint16Array_.Count); + foreach(ushort __vi__ in uint16Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)int8Array_.Count); + foreach(sbyte __vi__ in int8Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)uint8Array_.Count); + foreach(byte __vi__ in uint8Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)boolArray_.Count); + foreach(bool __vi__ in boolArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)strArray_.Count); + foreach(string __vi__ in strArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)strArray1_.Count); + foreach(string __vi__ in strArray1_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)binArray_.Count); + foreach(byte[] __vi__ in binArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)bin1Array_.Count); + foreach(byte[] __vi__ in bin1Array_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)enumArray_.Count); + foreach(EnumName __vi__ in enumArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + { + bintalk.ProtocolWriter.writeDynSize(__w__, (uint)structArray_.Count); + foreach(StructType __vi__ in structArray_) bintalk.ProtocolWriter.write(__w__, __vi__); + } + } + public bool deserialize(bintalk.IReader __r__) + { + if(!bintalk.ProtocolReader.read(__r__, ref double_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref float_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref int64_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref uint64_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref int32_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref uint32_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref int16_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref uint16_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref int8_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref uint8_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref bool_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref enum_, 0X2)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref enum16_, 0X100)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref struct_, 0X0)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref string_, 0XFFFFFFFF)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref string1_, 0X20)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref bin_, 0XFFFFFFFF)) return false; + if(!bintalk.ProtocolReader.read(__r__, ref bin1_, 0X20)) return false; + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + double __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + doubleArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + float __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + floatArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + long __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + int64Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + ulong __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + uint64Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + int __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + int32Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + uint __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + uint32Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + short __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + int16Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + ushort __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + uint16Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + sbyte __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + int8Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + byte __vi__ = 0; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + uint8Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + bool __vi__ = false; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + boolArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + string __vi__ = ""; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0XFFFFFFFF)) return false; + strArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0X8) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + string __vi__ = ""; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X10)) return false; + strArray1_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + byte[] __vi__ = new byte[0]; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0XFFFFFFFF)) return false; + binArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + byte[] __vi__ = new byte[0]; + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X20)) return false; + bin1Array_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + EnumName __vi__ = (EnumName)(0); + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X2)) return false; + enumArray_.Add(__vi__); + } + } + { + uint __s__; + if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0XFFFFFFFF) return false; + for(uint __i__ = 0; __i__ < __s__; __i__++) + { + StructType __vi__ = new StructType(); + if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X0)) return false; + structArray_.Add(__vi__); + } + } + return true; + } +} +namespace bintalk +{ + public static partial class ProtocolReader + { + public static bool read(bintalk.IReader r, ref StructBase v, uint maxValue) + { + return v.deserialize(r); + } + } + public static partial class ProtocolWriter + { + public static void write(bintalk.IWriter w, StructBase v) + { + v.serialize(w); + } + } +} diff --git a/src/writeLua/Example.lua b/src/writeLua/Example.lua new file mode 100644 index 0000000..e5a282d --- /dev/null +++ b/src/writeLua/Example.lua @@ -0,0 +1,562 @@ +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 diff --git a/src/writeLua/LUAGenerator.cpp b/src/writeLua/LUAGenerator.cpp new file mode 100644 index 0000000..3fe56d5 --- /dev/null +++ b/src/writeLua/LUAGenerator.cpp @@ -0,0 +1,161 @@ +#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::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()); + } +} \ No newline at end of file diff --git a/src/writeLua/reader.lua b/src/writeLua/reader.lua new file mode 100644 index 0000000..36f70e2 --- /dev/null +++ b/src/writeLua/reader.lua @@ -0,0 +1,189 @@ +---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(" 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 + +-- Read array of type t. +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, +} diff --git a/src/writeLua/types.lua b/src/writeLua/types.lua new file mode 100644 index 0000000..57b9526 --- /dev/null +++ b/src/writeLua/types.lua @@ -0,0 +1,111 @@ +---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, +} \ No newline at end of file diff --git a/src/writeLua/writer.lua b/src/writeLua/writer.lua new file mode 100644 index 0000000..2595883 --- /dev/null +++ b/src/writeLua/writer.lua @@ -0,0 +1,170 @@ +---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 + +-- Write int64 as string +---@param v number @value +---@param b string[] @buffer. +local function type_int64(v, b) + b[#b+1] = string.pack("