From 44cb7e77c76d51a5ba81442f3d85f49504e5681c Mon Sep 17 00:00:00 2001 From: SisMaker <1713699517@qq.com> Date: Fri, 7 May 2021 12:41:40 +0800 Subject: [PATCH] ft: add cs --- src/genProto.erl | 3 +- src/writeCs/CSGenerator.cpp | 214 ---------- src/writeCs/IReader.cs | 13 - src/writeCs/IWriter.cs | 9 - src/writeCs/ProtocolMsg.cs | 301 +++++++++++++ src/writeCs/ProtocolReader.cs | 148 ------- src/writeCs/ProtocolWriter.cs | 113 ----- src/writeCs/gCsCode.cs | 193 +++++++++ src/writeCs/gCsField.erl | 99 +++++ src/writeCs/gCsGen.erl | 766 +++++++++++++++++++++++++++++++++- src/writeCs/testExample.cs | 676 ------------------------------ 11 files changed, 1360 insertions(+), 1175 deletions(-) delete mode 100644 src/writeCs/CSGenerator.cpp delete mode 100644 src/writeCs/IReader.cs delete mode 100644 src/writeCs/IWriter.cs create mode 100644 src/writeCs/ProtocolMsg.cs delete mode 100644 src/writeCs/ProtocolReader.cs delete mode 100644 src/writeCs/ProtocolWriter.cs create mode 100644 src/writeCs/gCsCode.cs create mode 100644 src/writeCs/gCsField.erl delete mode 100644 src/writeCs/testExample.cs diff --git a/src/genProto.erl b/src/genProto.erl index b82523b..452383e 100644 --- a/src/genProto.erl +++ b/src/genProto.erl @@ -80,5 +80,6 @@ convertDir(ProtoDir, HrlDir, ErlDir) -> SortedErrList = lists:sort(fun({_ErrName1, ErrCodeId1, _Desc1}, {_ErrName2, ErrCodeId2, _Desc2}) -> ErrCodeId1 < ErrCodeId2 end, ErrCodeList), - gErlGen:genErl(SortedSProtoList, SortedErrList, HrlDir, ErlDir). + gErlGen:genErl(SortedSProtoList, SortedErrList, HrlDir, ErlDir), + gCsGen:genCs(SortedSProtoList, SortedErrList, HrlDir, ErlDir). %% 如果有其他语言请在这里添加入口函数 \ No newline at end of file diff --git a/src/writeCs/CSGenerator.cpp b/src/writeCs/CSGenerator.cpp deleted file mode 100644 index 87a7b09..0000000 --- a/src/writeCs/CSGenerator.cpp +++ /dev/null @@ -1,214 +0,0 @@ -#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 deleted file mode 100644 index b889318..0000000 --- a/src/writeCs/IReader.cs +++ /dev/null @@ -1,13 +0,0 @@ -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 deleted file mode 100644 index f706db2..0000000 --- a/src/writeCs/IWriter.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace bintalk -{ - /** Abstract interface for writing binary data. */ - public interface IWriter - { - /** Write some binary data. */ - void write(byte[] data); - } -} diff --git a/src/writeCs/ProtocolMsg.cs b/src/writeCs/ProtocolMsg.cs new file mode 100644 index 0000000..4953f65 --- /dev/null +++ b/src/writeCs/ProtocolMsg.cs @@ -0,0 +1,301 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; + +namespace GenProto +{ + public static class Protocol + { + public enum BasicTypeEnum + { + Boolean = 0x01, + Int8 = 0x02, + UInt8 = 0x03, + UInt16 = 0x04, + Int16 = 0x05, + Int32 = 0x06, + UInt32 = 0x07, + Int64 = 0x08, + UInt64 = 0x09, + Float = 0x10, + Double = 0x11, + String = 0x12, + } + + public static BasicTypeEnum JudgeType(T value) + { + return value switch + { + bool => BasicTypeEnum.Boolean, + byte => BasicTypeEnum.Int8, + sbyte => BasicTypeEnum.UInt8, + ushort => BasicTypeEnum.UInt16, + short => BasicTypeEnum.Int16, + int => BasicTypeEnum.Int32, + uint => BasicTypeEnum.UInt32, + long => BasicTypeEnum.Int64, + ulong => BasicTypeEnum.UInt64, + float => BasicTypeEnum.Float, + double => BasicTypeEnum.Double, + string => BasicTypeEnum.String, + _ => throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}") + }; + } + + public static void WriteValue(this BinaryWriter binaryWriter, T value) + { + switch (value) + { + case bool boolValue: + binaryWriter.Write(boolValue); + break; + case byte byteValue: + binaryWriter.Write(byteValue); + break; + case sbyte sbyteValue: + binaryWriter.Write(sbyteValue); + break; + case ushort ushortValue: + binaryWriter.Write(ushortValue); + break; + case short shortValue: + binaryWriter.Write(shortValue); + break; + case int intValue: + binaryWriter.Write(intValue); + break; + case uint uintValue: + binaryWriter.Write(uintValue); + break; + case long longValue: + binaryWriter.Write(longValue); + break; + case ulong ulongValue: + binaryWriter.Write(ulongValue); + break; + case float floatValue: + binaryWriter.Write(floatValue); + break; + case double doubleValue: + binaryWriter.Write(doubleValue); + break; + case string stringValue: + binaryWriter.Write(stringValue); + break; + default: + throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}"); + } + } + + + public static void WriteList(this BinaryWriter binaryWriter, IList list) + { + var length = (ushort) (list?.Count ?? 0); + binaryWriter.Write(length); + + if (list == null) return; + for (var idx = 0; idx < length; idx++) + { + var value = list[idx]; + + if (idx == 0) + { + var basicType = JudgeType(value); + binaryWriter.Write((byte) basicType); + } + + binaryWriter.WriteValue(value); + } + } + + public static void ReadList(this BinaryReader binaryReader, out IList list) + { + var length = binaryReader.ReadUInt16(); + if (length <= 0) + { + list = default; + return; + } + + list = default; + var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte(); + for (int idx = 0; idx < length; idx++) + { + switch (basicTypeEnum) + { + case BasicTypeEnum.Boolean: + list ??= new List(length); + var boolValue = binaryReader.ReadBoolean(); + list.Add(boolValue); + break; + case BasicTypeEnum.Int8: + list ??= new List(length); + var sbyteValue = binaryReader.ReadSByte(); + list.Add(sbyteValue); + break; + case BasicTypeEnum.UInt8: + list ??= new List(length); + var byteValue = binaryReader.ReadByte(); + list.Add(byteValue); + break; + case BasicTypeEnum.UInt16: + list ??= new List(length); + var ushortValue = binaryReader.ReadUInt16(); + list.Add(ushortValue); + break; + case BasicTypeEnum.Int16: + list ??= new List(length); + var shortValue = binaryReader.ReadInt16(); + list.Add(shortValue); + break; + case BasicTypeEnum.Int32: + list ??= new List(length); + var intValue = binaryReader.ReadInt32(); + list.Add(intValue); + break; + case BasicTypeEnum.UInt32: + list ??= new List(length); + var uintValue = binaryReader.ReadUInt32(); + list.Add(uintValue); + break; + case BasicTypeEnum.Int64: + list ??= new List(length); + var longValue = binaryReader.ReadInt64(); + list.Add(longValue); + break; + case BasicTypeEnum.UInt64: + list ??= new List(length); + var ulongValue = binaryReader.ReadUInt64(); + list.Add(ulongValue); + break; + case BasicTypeEnum.Float: + list ??= new List(length); + var singleValue = binaryReader.ReadSingle(); + list.Add(singleValue); + break; + case BasicTypeEnum.Double: + list ??= new List(length); + var doubleValue = binaryReader.ReadDouble(); + list.Add(doubleValue); + break; + case BasicTypeEnum.String: + list ??= new List(length); + var stringValue = binaryReader.ReadString(); + list.Add(stringValue); + break; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + } + + public class AllType + { + public bool Bool; + public sbyte Int8; + public byte UInt8; + public ushort UInt16; + public short Int16; + public int Int32; + public uint UInt32; + public long Int64; + public ulong UInt64; + public float Float; + public double Double; + public string String; + + public List ListBool; + public List ListInt8; + public List ListUInt8; + public List ListUInt16; + public List ListInt16; + public List ListInt32; + public List ListUInt32; + public List ListInt64; + public List ListUInt64; + public List ListFloat; + public List ListDouble; + public List ListString; + + public static byte[] Serialize(AllType allType) + { + using var memoryStream = new MemoryStream(); + using var binaryWriter = new BinaryWriter(memoryStream); + binaryWriter.Write(allType.Bool); + binaryWriter.Write(allType.Int8); + binaryWriter.Write(allType.UInt8); + binaryWriter.Write(allType.UInt16); + binaryWriter.Write(allType.Int16); + binaryWriter.Write(allType.Int32); + binaryWriter.Write(allType.UInt32); + binaryWriter.Write(allType.Int64); + binaryWriter.Write(allType.UInt64); + binaryWriter.Write(allType.Float); + binaryWriter.Write(allType.Double); + binaryWriter.Write(allType.String); + + binaryWriter.WriteList(allType.ListBool); + binaryWriter.WriteList(allType.ListInt8); + binaryWriter.WriteList(allType.ListUInt8); + binaryWriter.WriteList(allType.ListUInt16); + binaryWriter.WriteList(allType.ListInt16); + binaryWriter.WriteList(allType.ListInt32); + binaryWriter.WriteList(allType.ListUInt32); + binaryWriter.WriteList(allType.ListInt64); + binaryWriter.WriteList(allType.ListUInt64); + binaryWriter.WriteList(allType.ListFloat); + binaryWriter.WriteList(allType.ListDouble); + binaryWriter.WriteList(allType.ListString); + + return memoryStream.ToArray(); + } + + public static AllType Deserialize(byte[] data) + { + using var memoryStream = new MemoryStream(data); + using var binaryReader = new BinaryReader(memoryStream); + var allType = new AllType(); + allType.Bool = binaryReader.ReadBoolean(); + allType.Int8 = binaryReader.ReadSByte(); + allType.UInt8 = binaryReader.ReadByte(); + allType.UInt16 = binaryReader.ReadUInt16(); + allType.Int16 = binaryReader.ReadInt16(); + allType.Int32 = binaryReader.ReadInt32(); + allType.UInt32 = binaryReader.ReadUInt32(); + allType.Int64 = binaryReader.ReadInt64(); + allType.UInt64 = binaryReader.ReadUInt64(); + allType.Float = binaryReader.ReadSingle(); + allType.Double = binaryReader.ReadDouble(); + allType.String = binaryReader.ReadString(); + + binaryReader.ReadList(out var outListBool); + allType.ListBool = outListBool as List; + binaryReader.ReadList(out var outListInt8); + allType.ListInt8 = outListInt8 as List; + binaryReader.ReadList(out var outListUInt8); + allType.ListUInt8 = outListUInt8 as List; + binaryReader.ReadList(out var outListUInt16); + allType.ListUInt16 = outListUInt16 as List; + binaryReader.ReadList(out var outListInt16); + allType.ListInt16 = outListInt16 as List; + binaryReader.ReadList(out var outListInt32); + allType.ListInt32 = outListInt32 as List; + binaryReader.ReadList(out var outListUInt32); + allType.ListUInt32 = outListUInt32 as List; + binaryReader.ReadList(out var outListInt64); + allType.ListInt64 = outListInt64 as List; + binaryReader.ReadList(out var outListUInt64); + allType.ListUInt64 = outListUInt64 as List; + binaryReader.ReadList(out var outListFloat); + allType.ListFloat = outListFloat as List; + binaryReader.ReadList(out var outListDouble); + allType.ListDouble = outListDouble as List; + binaryReader.ReadList(out var outListString); + allType.ListString = outListString as List; + + return allType; + } + } +} \ No newline at end of file diff --git a/src/writeCs/ProtocolReader.cs b/src/writeCs/ProtocolReader.cs deleted file mode 100644 index 11436ce..0000000 --- a/src/writeCs/ProtocolReader.cs +++ /dev/null @@ -1,148 +0,0 @@ -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 deleted file mode 100644 index 9c7daf0..0000000 --- a/src/writeCs/ProtocolWriter.cs +++ /dev/null @@ -1,113 +0,0 @@ -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/gCsCode.cs b/src/writeCs/gCsCode.cs new file mode 100644 index 0000000..f407563 --- /dev/null +++ b/src/writeCs/gCsCode.cs @@ -0,0 +1,193 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; + +namespace ProtoMsg +{ + public static class Protocol + { + public enum BasicTypeEnum + { + Boolean = 0x01, + Int8 = 0x02, + UInt8 = 0x03, + UInt16 = 0x04, + Int16 = 0x05, + Int32 = 0x06, + UInt32 = 0x07, + Int64 = 0x08, + UInt64 = 0x09, + Float = 0x10, + Double = 0x11, + String = 0x12, + } + + public static BasicTypeEnum JudgeType(T value) + { + return value switch + { + bool => BasicTypeEnum.Boolean, + byte => BasicTypeEnum.Int8, + sbyte => BasicTypeEnum.UInt8, + ushort => BasicTypeEnum.UInt16, + short => BasicTypeEnum.Int16, + int => BasicTypeEnum.Int32, + uint => BasicTypeEnum.UInt32, + long => BasicTypeEnum.Int64, + ulong => BasicTypeEnum.UInt64, + float => BasicTypeEnum.Float, + double => BasicTypeEnum.Double, + string => BasicTypeEnum.String, + _ => throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}") + }; + } + + public static void WriteValue(this BinaryWriter binaryWriter, T value) + { + switch (value) + { + case bool boolValue: + binaryWriter.Write(boolValue); + break; + case byte byteValue: + binaryWriter.Write(byteValue); + break; + case sbyte sbyteValue: + binaryWriter.Write(sbyteValue); + break; + case ushort ushortValue: + binaryWriter.Write(ushortValue); + break; + case short shortValue: + binaryWriter.Write(shortValue); + break; + case int intValue: + binaryWriter.Write(intValue); + break; + case uint uintValue: + binaryWriter.Write(uintValue); + break; + case long longValue: + binaryWriter.Write(longValue); + break; + case ulong ulongValue: + binaryWriter.Write(ulongValue); + break; + case float floatValue: + binaryWriter.Write(floatValue); + break; + case double doubleValue: + binaryWriter.Write(doubleValue); + break; + case string stringValue: + binaryWriter.Write(stringValue); + break; + default: + throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}"); + } + } + + + public static void WriteList(this BinaryWriter binaryWriter, IList list) + { + var length = (ushort) (list?.Count ?? 0); + binaryWriter.Write(length); + + if (list == null) return; + for (var idx = 0; idx < length; idx++) + { + var value = list[idx]; + + if (idx == 0) + { + var basicType = JudgeType(value); + binaryWriter.Write((byte) basicType); + } + + binaryWriter.WriteValue(value); + } + } + + public static void ReadList(this BinaryReader binaryReader, out IList list) + { + var length = binaryReader.ReadUInt16(); + if (length <= 0) + { + list = default; + return; + } + + list = default; + var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte(); + for (int idx = 0; idx < length; idx++) + { + switch (basicTypeEnum) + { + case BasicTypeEnum.Boolean: + list ??= new List(length); + var boolValue = binaryReader.ReadBoolean(); + list.Add(boolValue); + break; + case BasicTypeEnum.Int8: + list ??= new List(length); + var sbyteValue = binaryReader.ReadSByte(); + list.Add(sbyteValue); + break; + case BasicTypeEnum.UInt8: + list ??= new List(length); + var byteValue = binaryReader.ReadByte(); + list.Add(byteValue); + break; + case BasicTypeEnum.UInt16: + list ??= new List(length); + var ushortValue = binaryReader.ReadUInt16(); + list.Add(ushortValue); + break; + case BasicTypeEnum.Int16: + list ??= new List(length); + var shortValue = binaryReader.ReadInt16(); + list.Add(shortValue); + break; + case BasicTypeEnum.Int32: + list ??= new List(length); + var intValue = binaryReader.ReadInt32(); + list.Add(intValue); + break; + case BasicTypeEnum.UInt32: + list ??= new List(length); + var uintValue = binaryReader.ReadUInt32(); + list.Add(uintValue); + break; + case BasicTypeEnum.Int64: + list ??= new List(length); + var longValue = binaryReader.ReadInt64(); + list.Add(longValue); + break; + case BasicTypeEnum.UInt64: + list ??= new List(length); + var ulongValue = binaryReader.ReadUInt64(); + list.Add(ulongValue); + break; + case BasicTypeEnum.Float: + list ??= new List(length); + var singleValue = binaryReader.ReadSingle(); + list.Add(singleValue); + break; + case BasicTypeEnum.Double: + list ??= new List(length); + var doubleValue = binaryReader.ReadDouble(); + list.Add(doubleValue); + break; + case BasicTypeEnum.String: + list ??= new List(length); + var stringValue = binaryReader.ReadString(); + list.Add(stringValue); + break; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + } +} \ No newline at end of file diff --git a/src/writeCs/gCsField.erl b/src/writeCs/gCsField.erl new file mode 100644 index 0000000..2cdac94 --- /dev/null +++ b/src/writeCs/gCsField.erl @@ -0,0 +1,99 @@ +-module(gCsField). + +-compile([export_all, nowarn_export_all]). + +-define(SimpleList, [ + <<"int8">> + , <<"uint8">> + , <<"int16">> + , <<"uint16">> + , <<"int32">> + , <<"uint32">> + , <<"int64">> + , <<"uint64">> + , <<"float">> + , <<"double">> +]). + +-define(TypeList, [ + <<"bool">> + , <<"int8">> + , <<"uint8">> + , <<"int16">> + , <<"uint16">> + , <<"int32">> + , <<"uint32">> + , <<"int64">> + , <<"uint64">> + , <<"integer">> + , <<"number">> + , <<"float">> + , <<"double">> + , <<"string">> +]). + +-define(TypeValue, [ + {<<"bool">>, <<"false">>, <<"boolean()">>} + , {<<"int8">>, <<"0">>, <<"int8()">>} + , {<<"uint8">>, <<"0">>, <<"uint8()">>} + , {<<"int16">>, <<"0">>, <<"int16()">>} + , {<<"uint16">>, <<"0">>, <<"uint16()">>} + , {<<"int32">>, <<"0">>, <<"int32()">>} + , {<<"uint32">>, <<"0">>, <<"uint32()">>} + , {<<"int64">>, <<"0">>, <<"int64()">>} + , {<<"uint64">>, <<"0">>, <<"uint64()">>} + , {<<"integer">>, <<"0">>, <<"integer()">>} + , {<<"number">>, <<"0">>, <<"number()">>} + , {<<"float">>, <<"0.0">>, <<"float()">>} + , {<<"double">>, <<"0.0">>, <<"double()">>} + , {<<"string">>, <<"\"\"">>, <<"string()">>} +]). + +builtRecStr({TypeStr, NameStr}) -> + case lists:keyfind(TypeStr, 1, ?TypeValue) of + {TypeStr, DefValueStr, DefTypeStr} -> + <>; + _ -> + case TypeStr of + <<"list[", LeftStr/binary>> -> + [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]), + case lists:keyfind(SubTypeStr, 1, ?TypeValue) of + {SubTypeStr, _DefSubValueStr, DefSubTypeStr} -> + <>; + _ -> + <> + end; + _ -> + <> + end + end. + +builtPackStr(TypeStr) -> + case lists:member(TypeStr, ?TypeList) of + true -> + <<"?", TypeStr/binary, "(">>; + _ -> + case TypeStr of + <<"list[", LeftStr/binary>> -> + [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]), + SubStr = + case lists:member(SubTypeStr, ?TypeList) of + true -> + SubTypeStr; + _ -> + <<"record">> + end, + <<"?list_", SubStr/binary, "(">>; + _ -> + <<"?record(">> + end + end. + +isBaseType(TypeStr) -> + lists:member(TypeStr, ?TypeList). + + + + + + diff --git a/src/writeCs/gCsGen.erl b/src/writeCs/gCsGen.erl index 508bd43..ce1ac71 100644 --- a/src/writeCs/gCsGen.erl +++ b/src/writeCs/gCsGen.erl @@ -1,8 +1,772 @@ -module(gCsGen). +-include("genDef.hrl"). -export([ genCs/4 ]). -genCs(_SortedSProtoList, _SortedErrList, _HrlDir, _ErlDir) -> +protoHeader() -> +<<"using System; +using System.Collections; +using System.Collections.Generic; +using System.IO; + +namespace ProtoMsg +{ + public static class Protocol + { + public enum BasicTypeEnum + { + Boolean = 0x01, + Int8 = 0x02, + UInt8 = 0x03, + UInt16 = 0x04, + Int16 = 0x05, + Int32 = 0x06, + UInt32 = 0x07, + Int64 = 0x08, + UInt64 = 0x09, + Float = 0x10, + Double = 0x11, + String = 0x12, + } + + public static BasicTypeEnum JudgeType(T value) + { + return value switch + { + bool => BasicTypeEnum.Boolean, + byte => BasicTypeEnum.Int8, + sbyte => BasicTypeEnum.UInt8, + ushort => BasicTypeEnum.UInt16, + short => BasicTypeEnum.Int16, + int => BasicTypeEnum.Int32, + uint => BasicTypeEnum.UInt32, + long => BasicTypeEnum.Int64, + ulong => BasicTypeEnum.UInt64, + float => BasicTypeEnum.Float, + double => BasicTypeEnum.Double, + string => BasicTypeEnum.String, + _ => throw new InvalidOperationException($\"unexpect type: {value.GetType().FullName}\") + }; + } + + public static void WriteValue(this BinaryWriter binaryWriter, T value) + { + switch (value) + { + case bool boolValue: + binaryWriter.Write(boolValue); + break; + case byte byteValue: + binaryWriter.Write(byteValue); + break; + case sbyte sbyteValue: + binaryWriter.Write(sbyteValue); + break; + case ushort ushortValue: + binaryWriter.Write(ushortValue); + break; + case short shortValue: + binaryWriter.Write(shortValue); + break; + case int intValue: + binaryWriter.Write(intValue); + break; + case uint uintValue: + binaryWriter.Write(uintValue); + break; + case long longValue: + binaryWriter.Write(longValue); + break; + case ulong ulongValue: + binaryWriter.Write(ulongValue); + break; + case float floatValue: + binaryWriter.Write(floatValue); + break; + case double doubleValue: + binaryWriter.Write(doubleValue); + break; + case string stringValue: + binaryWriter.Write(stringValue); + break; + default: + throw new InvalidOperationException($\"unexpect type: {value.GetType().FullName}\"); + } + } + + + public static void WriteList(this BinaryWriter binaryWriter, IList list) + { + var length = (ushort) (list?.Count ?? 0); + binaryWriter.Write(length); + + if (list == null) return; + for (var idx = 0; idx < length; idx++) + { + var value = list[idx]; + + if (idx == 0) + { + var basicType = JudgeType(value); + binaryWriter.Write((byte) basicType); + } + + binaryWriter.WriteValue(value); + } + } + + public static void ReadList(this BinaryReader binaryReader, out IList list) + { + var length = binaryReader.ReadUInt16(); + if (length <= 0) + { + list = default; + return; + } + + list = default; + var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte(); + for (int idx = 0; idx < length; idx++) + { + switch (basicTypeEnum) + { + case BasicTypeEnum.Boolean: + list ??= new List(length); + var boolValue = binaryReader.ReadBoolean(); + list.Add(boolValue); + break; + case BasicTypeEnum.Int8: + list ??= new List(length); + var sbyteValue = binaryReader.ReadSByte(); + list.Add(sbyteValue); + break; + case BasicTypeEnum.UInt8: + list ??= new List(length); + var byteValue = binaryReader.ReadByte(); + list.Add(byteValue); + break; + case BasicTypeEnum.UInt16: + list ??= new List(length); + var ushortValue = binaryReader.ReadUInt16(); + list.Add(ushortValue); + break; + case BasicTypeEnum.Int16: + list ??= new List(length); + var shortValue = binaryReader.ReadInt16(); + list.Add(shortValue); + break; + case BasicTypeEnum.Int32: + list ??= new List(length); + var intValue = binaryReader.ReadInt32(); + list.Add(intValue); + break; + case BasicTypeEnum.UInt32: + list ??= new List(length); + var uintValue = binaryReader.ReadUInt32(); + list.Add(uintValue); + break; + case BasicTypeEnum.Int64: + list ??= new List(length); + var longValue = binaryReader.ReadInt64(); + list.Add(longValue); + break; + case BasicTypeEnum.UInt64: + list ??= new List(length); + var ulongValue = binaryReader.ReadUInt64(); + list.Add(ulongValue); + break; + case BasicTypeEnum.Float: + list ??= new List(length); + var singleValue = binaryReader.ReadSingle(); + list.Add(singleValue); + break; + case BasicTypeEnum.Double: + list ??= new List(length); + var doubleValue = binaryReader.ReadDouble(); + list.Add(doubleValue); + break; + case BasicTypeEnum.String: + list ??= new List(length); + var stringValue = binaryReader.ReadString(); + list.Add(stringValue); + break; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + }">>. + +protoEnd() -> + <<"}">>. + +genMsgHrl([], _Index, _Len, HrlBinStr) -> + HrlBinStr; +genMsgHrl([FieldInfo | FieldList], Index, Len, HrlBinStr) -> + TemStr = + case Index of + Len -> + <<"">>; + _ -> + <<", ">> + end, + RecStr = < <<"">>; _ -> <<"\t">> end)/binary>>, + genMsgHrl(FieldList, Index - 1, Len, <>). + +spellHead([], _Index, HeadBinStr) -> + HeadBinStr; +spellHead([_FieldInfo | FieldList], Index, HeadBinStr) -> + spellHead(FieldList, Index + 1, <>). + +spellBody([], _Index, BodyBinStr) -> + BodyBinStr; +spellBody([{FieldType, _FieldName}], Index, BodyBinStr) -> + TemV = <<"V", (integer_to_binary(Index))/binary>>, + <>; +spellBody([{FieldType, _FieldName} | FieldList], Index, BodyBinStr) -> + TemV = <<"V", (integer_to_binary(Index))/binary>>, + NewBodyBinStr = <>, + spellBody(FieldList, Index + 1, NewBodyBinStr). + +spellErrCodeHrl([], ErrBinStr) -> + ErrBinStr; +spellErrCodeHrl([{ErrName, ErrCodeId, ComDesc} | SortedErrList], ErrBinStr) -> + ErrStr = <<"-define(", ErrName/binary, ", ", (integer_to_binary(ErrCodeId))/binary, ").\t\t%% ", ComDesc/binary, "\n">>, + spellErrCodeHrl(SortedErrList, <>). + +genEncodeRec({MsgName, MsgId, FieldList}, IsForBin) -> + FieldLen = length(FieldList), + TemStr = spellHead(FieldList, 1, <<"">>), + HeadStr = + case IsForBin of + true -> + <<"encodeIol(", MsgName/binary, ", {_", TemStr/binary, "}) ->\n\t">>; + _ -> + <<"subEncode(", MsgName/binary, ", {_", TemStr/binary, "}) ->\n\t">> + end, + + BodyStr = spellBody(FieldList, 1, <<"">>), + case IsForBin of + true -> + case FieldLen > 0 of + true -> + <>, ", BodyStr/binary, "];\n">>; + _ -> + <>];\n">> + end; + _ -> + case FieldLen > 0 of + true -> + <>; + _ -> + <> + end + end. + +resetPd() -> + erlang:put(pd_v, 0), + erlang:put(pd_len, 0), + erlang:put(pd_bool, 0), + erlang:put(pd_leftBin, 0), + erlang:put(pd_intBits, 0), + erlang:put(pd_numBits, 0), + erlang:put(pd_listBin, 0), + erlang:put(pd_isUndef, 0), + erlang:put(pd_isCalcRefSize, 0). + +getIndexStr(Type) -> + Index = erlang:get(Type), + integer_to_binary(Index). + +useIndexStr(Type) -> + Index = erlang:get(Type) + 1, + erlang:put(Type, Index), + integer_to_binary(Index). + +isCalcRefSize() -> + erlang:get(pd_isCalcRefSize) > 0. + +initSubRec() -> + erlang:put(pd_subRec, []). + +getSubRec() -> + erlang:get(pd_subRec). + +initSubSubRec() -> + erlang:put(pd_subSubRec, []). + +getSubSubRec() -> + erlang:get(pd_subSubRec). + +addSubRec({MsgName, _MsgId, _FieldList} = Info, IsForBin) when IsForBin -> + OldList = erlang:get(pd_subRec), + case lists:keyfind(MsgName, 1, OldList) of + false -> + erlang:put(pd_subRec, [Info | OldList]); + _ -> + ignore + end; +addSubRec({MsgName, _MsgId, _FieldList} = Info, _IsForBin) -> + OldAllList = erlang:get(pd_subRec), + case lists:keyfind(MsgName, 1, OldAllList) of + false -> + erlang:put(pd_subRec, [Info | OldAllList]), + OldSubList = erlang:get(pd_subSubRec), + case lists:keyfind(MsgName, 1, OldSubList) of + false -> + erlang:put(pd_subSubRec, [Info | OldSubList]); + _ -> + ignore + end; + _ -> + ignore + end. + +genDecodeBin({MsgName, MsgId, FieldList}, SortedSProtoList, IsForBin) -> + FieldLen = length(FieldList), + case IsForBin of + true -> + HeadStr = <<"decodeBin(", (integer_to_binary(MsgId))/binary, ", LeftBin", (getIndexStr(pd_leftBin))/binary, ") ->\n">>; + _ -> + HeadStr = <<"decodeRec(", (integer_to_binary(MsgId))/binary, ", LeftBin", (getIndexStr(pd_leftBin))/binary, ") ->\n">> + end, + + FunBody = + fun({FieldType, _FieldName}, {IsSimple, StrAcc}) -> + case FieldType of + <<"bool">> -> + TemStr = + case IsSimple of + true -> + GetLeftBinStr1 = getIndexStr(pd_leftBin), + UseLeftBinStr1 = useIndexStr(pd_leftBin), + <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>; + _ -> + <<"">> + end, + UseBoolStr = useIndexStr(pd_bool), + GetLeftBinStr2 = getIndexStr(pd_leftBin), + UseLeftBinStr2 = useIndexStr(pd_leftBin), + BoolStr = <<"\t<> = LeftBin", GetLeftBinStr2/binary, ",\n">>, + UseVStr = useIndexStr(pd_v), + VStr = <<"\tV", UseVStr/binary, " = Bool", UseBoolStr/binary, " =:= 1,\n">>, + {false, <>}; + <<"int8">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":8/big-signed, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"uint8">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":8/big-unsigned, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"int16">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":16/big-signed, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"uint16">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":16/big-unsigned, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"int32">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":32/big-signed, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"uint32">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":32/big-unsigned, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"int64">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":64/big-signed, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"uint64">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":64/big-unsigned, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"float">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":32/big-float, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"double">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + <<"V", UseVStr/binary, ":64/big-float, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + <<"\t<> + end, + {true, <>}; + <<"string">> -> + TemStr = + case IsSimple of + true -> + GetLeftBinStr1 = getIndexStr(pd_leftBin), + UseLeftBinStr1 = useIndexStr(pd_leftBin), + <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>; + _ -> + <<"">> + end, + UseLenStr = useIndexStr(pd_len), + GetLeftBinStr2 = getIndexStr(pd_leftBin), + UseLeftBinStr2 = useIndexStr(pd_leftBin), + UseVStr = useIndexStr(pd_v), + RefSizeStr = + case isCalcRefSize() of + false -> + useIndexStr(pd_isCalcRefSize), + <<"\tRefSize = binary:referenced_byte_size(LeftBin0),\n">>; + _ -> + <<"">> + end, + StrStr = <<"\t<> = LeftBin", GetLeftBinStr2/binary, ",\n">>, + VStr = <<"\tcase Len", UseLenStr/binary, " < ?BinaryShareSize of\n\t\t", + "true ->\n\t\t\tV", UseVStr/binary, " = TemStrV", UseVStr/binary, ";\n\t\t", + "_ ->\n\t\t\tcase RefSize / Len", UseLenStr/binary, " > ?BinaryCopyRatio of\n\t\t\t\t", + "true ->\n\t\t\t\t\tV", UseVStr/binary, " = binary:copy(TemStrV", UseVStr/binary, ");\n\t\t\t\t", + "_ ->\n\t\t\t\t\tV", UseVStr/binary, " = TemStrV", UseVStr/binary, "\n\t\t\tend\n\tend,\n">>, + {false, <>}; + <<"integer">> -> + TemStr = + case IsSimple of + true -> + UseVStr = useIndexStr(pd_v), + UseIntBitsStr = useIndexStr(pd_intBits), + <<"IntBits", UseIntBitsStr/binary, ":8, V", UseVStr/binary, ":IntBits", UseIntBitsStr/binary, "/big-signed, ">>; + _ -> + UseVStr = useIndexStr(pd_v), + UseIntBitsStr = useIndexStr(pd_intBits), + <<"\t<> + end, + {true, <>}; + <<"number">> -> + TemStr = + case IsSimple of + true -> + GetLeftBinStr1 = getIndexStr(pd_leftBin), + UseLeftBinStr1 = useIndexStr(pd_leftBin), + <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>; + _ -> + <<"">> + end, + UseNumBitsStr = useIndexStr(pd_numBits), + GetLeftBinStr2 = getIndexStr(pd_leftBin), + UseLeftBinStr2 = useIndexStr(pd_leftBin), + NumStr = <<"\t<> = LeftBin", GetLeftBinStr2/binary, ",\n">>, + UseVStr = useIndexStr(pd_v), + UseLeftBinStr3 = useIndexStr(pd_leftBin), + VStr = + <<"\tcase NumBits", UseNumBitsStr/binary, " of\n\t\t33-> \n\t\t\t<> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t65 ->\n\t\t\t<> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t_ ->\n\t\t\t<> = LeftBin", UseLeftBinStr2/binary, "\n\tend,\n">>, + {false, <>}; + <<"list[", LeftStr/binary>> -> + [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]), + TemStr = + case IsSimple of + true -> + GetLeftBinStr1 = getIndexStr(pd_leftBin), + UseLeftBinStr1 = useIndexStr(pd_leftBin), + <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>; + _ -> + <<"">> + end, + + UseLenStr = useIndexStr(pd_len), + GetLeftBinStr2 = getIndexStr(pd_leftBin), + UseLeftBinStr2 = useIndexStr(pd_leftBin), + UseVStr = useIndexStr(pd_v), + UseListBinStr = useIndexStr(pd_listBin), + GetLeftBinStr3 = getIndexStr(pd_leftBin), + UseLeftBinStr3 = useIndexStr(pd_leftBin), + LenStr = <<"\t<> = LeftBin", GetLeftBinStr2/binary, ",\n">>, + DeListStr = + case SubTypeStr of + <<"bool">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV =:= 1 || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"int8">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"uint8">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"int16">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"uint16">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"int32">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"uint32">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"int64">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"uint64">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"integer">> -> + <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deIntegerList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>; + <<"number">> -> + <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deNumberList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>; + <<"float">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"double">> -> + ListBinStr = <<"\t<> = LeftBin", GetLeftBinStr3/binary, ",\n">>, + VStr = <<"\tV", UseVStr/binary, " = [TemV || <> <= ListBin", UseListBinStr/binary, "],\n">>, + <>; + <<"string">> -> + case isCalcRefSize() of + true -> + <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deStringList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", RefSize, []),\n">>; + _ -> + useIndexStr(pd_isCalcRefSize), + RefSizeStr = <<"\tRefSize = binary:referenced_byte_size(LeftBin0),\n">>, + VStr = <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deStringList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", RefSize, []),\n">>, + <> + end; + ListRecord -> + case lists:keyfind(ListRecord, 1, SortedSProtoList) of + {ListRecord, ListMsgId, _} = RecordInfo -> + addSubRec(RecordInfo, IsForBin), + <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deRecordList(Len", UseLenStr/binary, ", ", (integer_to_binary(ListMsgId))/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>; + _ -> + io:format("this an Record undefined :~p~n", [ListRecord]), + throw(record_undefined) + end + end, + {false, <>}; + OtherRecord -> + TemStr = + case IsSimple of + true -> + GetLeftBinStr1 = getIndexStr(pd_leftBin), + UseLeftBinStr1 = useIndexStr(pd_leftBin), + <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>; + _ -> + <<"">> + end, + UseIsUndefStr = useIndexStr(pd_isUndef), + GetLeftBinStr2 = getIndexStr(pd_leftBin), + UseLeftBinStr2 = useIndexStr(pd_leftBin), + IsStr = <<"\t<> = LeftBin", GetLeftBinStr2/binary, ",\n">>, + UseVStr = useIndexStr(pd_v), + UseLeftBinStr3 = useIndexStr(pd_leftBin), + case lists:keyfind(OtherRecord, 1, SortedSProtoList) of + {OtherRecord, OtherMsgId, _} = RecordInfo -> + addSubRec(RecordInfo, IsForBin), + VStr = <<"\tcase IsUndef", UseIsUndefStr/binary, " of\n\t\t0 ->\n\t\t\tV", UseVStr/binary, " = undefined,\n\t\t\tLeftBin", UseLeftBinStr3/binary, " = LeftBin", UseLeftBinStr2/binary, + " ;\n\t\t_ ->\n\t\t\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = ", "decodeRec(", (integer_to_binary(OtherMsgId))/binary, ", LeftBin", UseLeftBinStr2/binary, ")\n\tend,\n">>, + {false, <>}; + _ -> + io:format("this an Record undefined :~p~n", [OtherRecord]), + throw(record_undefined) + end + end + end, + + {LIsSimple, BodyStr} = lists:foldl(FunBody, {false, <<"">>}, FieldList), + LBodyStr = + case LIsSimple of + true -> + LGetLeftBinStr = getIndexStr(pd_leftBin), + LUseLeftBinStr = useIndexStr(pd_leftBin), + <> = LeftBin", LGetLeftBinStr/binary, ",\n">>; + _ -> + BodyStr + end, + + RetStr = + case IsForBin of + true -> + MsgIndex = MsgId div ?MsgIdSegSize, + Handler = erlang:get(pd_handler), + {MsgIndex, ModName} = lists:keyfind(MsgIndex, 1, Handler), + HandleName = <>, + case FieldLen > 0 of + true -> + FunRec = + fun(N, Acc) -> + <> + end, + RecStr = lists:foldl(FunRec, <<"">>, lists:seq(1, FieldLen)), + <<"\t{", HandleName/binary, ", ", MsgName/binary, ", {", MsgName/binary, RecStr/binary, "}};\n">>; + _ -> + <<"\t{", HandleName/binary, ", ", MsgName/binary, ", {", MsgName/binary, "}};\n">> + end; + _ -> + case FieldLen > 0 of + true -> + FunRec = + fun(N, Acc) -> + <> + end, + RecStr = lists:foldl(FunRec, <<"">>, lists:seq(1, FieldLen)), + <<"\tMsgRec = {", MsgName/binary, RecStr/binary, "},\n\t{MsgRec, LeftBin", (getIndexStr(pd_leftBin))/binary, "};\n">>; + _ -> + <<"\t{{", MsgName/binary, "}, ", "<<>>};\n">> + end + end, + <>. + +genCs(SortedSProtoList, SortedErrList, HrlDir, ErlDir) -> + initSubRec(), + FunSpell = + fun({MsgName, MsgId, FieldList} = MsgInfo, {MsgHrlAcc, MsgEncodeAcc, MsgDecodeAcc, MsgIdAcc, MsgNameAcc}) -> + %% gen hrl str + Len = erlang:length(FieldList), + LastFieldStr = genMsgHrl(FieldList, Len, Len, <<"">>), + HrlStr = <<"-record(", MsgName/binary, ", {\n\t", LastFieldStr/binary, "}).\n">>, + + %% gen getMsgId getMsgType str + IdStr = <<"getMsgId(", MsgName/binary, ")-> ", (integer_to_binary(MsgId))/binary, ";\n">>, + NameStr = <<"getMsgName(", (integer_to_binary(MsgId))/binary, ")-> ", MsgName/binary, ";\n">>, + + %% gen encodeRec Str + EncodeStr = genEncodeRec(MsgInfo, true), + + %% gen decodeBin str + resetPd(), + DecodeStr = genDecodeBin(MsgInfo, SortedSProtoList, true), + + {<>, <>, <>, <>, <>} + end, + {MsgHrlStr, TMsgEncodeStr, TMsgDecodeStr, _TMsgIdStr, _TMsgNameStr} = lists:foldl(FunSpell, {<<>>, <<>>, <<>>, <<>>, <<>>}, SortedSProtoList), + MsgEncodeStr = <\n\t[].\n\n">>, + MsgDecodeStr = <\n\t{undefinedHer, undefined, {}}.\n\n">>, + _MsgIdStr = <<_TMsgIdStr/binary, "getMsgId(_) -> 0.\n\n">>, + _MsgNameStr = <<_TMsgNameStr/binary, "getMsgName(_) -> undefiend.\n\n">>, + + ErrCodeStr = spellErrCodeHrl(SortedErrList, <<>>), + + %% gen decodeRec str + SubRecList = getSubRec(), + initSubSubRec(), + SortedSubRecList = lists:sort(fun({_Name1, MessageId1, _FieldList1}, {_Name2, MessageId2, _FieldList2}) -> MessageId1 < MessageId2 end, SubRecList), + {MsgEncodeRecStr, MsgDecodeRecStr} = dealSubRec(SortedSubRecList, SortedSProtoList, <<"">>, <<"">>), + + ErlHeaderStr = protoErlHeader(), + HrlHeaderStr = protoHrlHeader(), + OutputErlStr = <>, + OutputHrlStr = <>, + HrlFilename = do_write_hrl(HrlDir, protoMsg, OutputHrlStr), + ErlFilename = do_write_erl(ErlDir, protoMsg, OutputErlStr), + + io:format("protoConvert hrl dir : ~s ~n", [HrlDir]), + io:format("protoConvert erl dir : ~s ~n", [ErlDir]), + io:format("protoConvert to hrl file ~s succ.~n", [HrlFilename]), + io:format("protoConvert to erl file ~s succ.~n", [ErlFilename]), ok. + +dealSubRec([], SortedSProtoList, SubEncodeAcc, SubDecodeAcc) -> + case getSubSubRec() of + [] -> + {<\n\t[].\n\n">>, <\n\t{{}, <<>>}.\n\n">>}; + NewAddList -> + initSubSubRec(), + SortedSubRecList = lists:sort(fun({_Name1, MessageId1, _FieldList1}, {_Name2, MessageId2, _FieldList2}) -> MessageId1 < MessageId2 end, NewAddList), + dealSubRec(SortedSubRecList, SortedSProtoList, SubEncodeAcc, SubDecodeAcc) + end; +dealSubRec([MsgInfo | SubRecList], SortedSProtoList, SubEncodeAcc, SubDecodeAcc) -> + EncodeStr = genEncodeRec(MsgInfo, false), + resetPd(), + DecodeStr = genDecodeBin(MsgInfo, SortedSProtoList, false), + dealSubRec(SubRecList, SortedSProtoList, <>, <>). + +do_write_hrl(OutDir, Mod, BinStr) -> + Filename = filename:join([OutDir, atom_to_list(Mod) ++ ".hrl"]), + ok = file:write_file(Filename, BinStr), + Filename. + +do_write_erl(OutDir, Mod, BinStr) -> + Filename = filename:join([OutDir, atom_to_list(Mod) ++ ".erl"]), + case file:write_file(Filename, BinStr) of + ok -> + ok; + _Ret -> + io:format("write to erl file error:~p ~n", [_Ret]) + end, + Filename. + diff --git a/src/writeCs/testExample.cs b/src/writeCs/testExample.cs deleted file mode 100644 index dc83769..0000000 --- a/src/writeCs/testExample.cs +++ /dev/null @@ -1,676 +0,0 @@ -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); - } - } -}