SisMaker
/
genProto
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Projects 0 Wydania 3 Wiki Aktywność
Przeglądaj źródła

Merge remote-tracking branch 'origin/master' into master

master
SisMaker 4 lat temu
rodzic
19f231c995 44cb7e77c7
commit
f6359ad033
11 zmienionych plików z 1360 dodań i 1175 usunięć
Widok podzielony
Opcje porównania
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania
  1. +2
    -1
      src/genProto.erl
  2. +0
    -214
      src/writeCs/CSGenerator.cpp
  3. +0
    -13
      src/writeCs/IReader.cs
  4. +0
    -9
      src/writeCs/IWriter.cs
  5. +301
    -0
      src/writeCs/ProtocolMsg.cs
  6. +0
    -148
      src/writeCs/ProtocolReader.cs
  7. +0
    -113
      src/writeCs/ProtocolWriter.cs
  8. +193
    -0
      src/writeCs/gCsCode.cs
  9. +99
    -0
      src/writeCs/gCsField.erl
  10. +765
    -1
      src/writeCs/gCsGen.erl
  11. +0
    -676
      src/writeCs/testExample.cs

+ 2
- 1
src/genProto.erl Wyświetl plik

@ -90,5 +90,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).
%% 如果有其他语言请在这里添加入口函数

+ 0
- 214
src/writeCs/CSGenerator.cpp Wyświetl plik

@ -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());
}
}

+ 0
- 13
src/writeCs/IReader.cs Wyświetl plik

@ -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);
}
}

+ 0
- 9
src/writeCs/IWriter.cs Wyświetl plik

@ -1,9 +0,0 @@
namespace bintalk
{
/** Abstract interface for writing binary data. */
public interface IWriter
{
/** Write some binary data. */
void write(byte[] data);
}
}

+ 301
- 0
src/writeCs/ProtocolMsg.cs Wyświetl plik

@ -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>(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<T>(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<T>(this BinaryWriter binaryWriter, IList<T> 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<bool>(length);
var boolValue = binaryReader.ReadBoolean();
list.Add(boolValue);
break;
case BasicTypeEnum.Int8:
list ??= new List<sbyte>(length);
var sbyteValue = binaryReader.ReadSByte();
list.Add(sbyteValue);
break;
case BasicTypeEnum.UInt8:
list ??= new List<byte>(length);
var byteValue = binaryReader.ReadByte();
list.Add(byteValue);
break;
case BasicTypeEnum.UInt16:
list ??= new List<ushort>(length);
var ushortValue = binaryReader.ReadUInt16();
list.Add(ushortValue);
break;
case BasicTypeEnum.Int16:
list ??= new List<short>(length);
var shortValue = binaryReader.ReadInt16();
list.Add(shortValue);
break;
case BasicTypeEnum.Int32:
list ??= new List<int>(length);
var intValue = binaryReader.ReadInt32();
list.Add(intValue);
break;
case BasicTypeEnum.UInt32:
list ??= new List<uint>(length);
var uintValue = binaryReader.ReadUInt32();
list.Add(uintValue);
break;
case BasicTypeEnum.Int64:
list ??= new List<long>(length);
var longValue = binaryReader.ReadInt64();
list.Add(longValue);
break;
case BasicTypeEnum.UInt64:
list ??= new List<ulong>(length);
var ulongValue = binaryReader.ReadUInt64();
list.Add(ulongValue);
break;
case BasicTypeEnum.Float:
list ??= new List<float>(length);
var singleValue = binaryReader.ReadSingle();
list.Add(singleValue);
break;
case BasicTypeEnum.Double:
list ??= new List<double>(length);
var doubleValue = binaryReader.ReadDouble();
list.Add(doubleValue);
break;
case BasicTypeEnum.String:
list ??= new List<string>(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<bool> ListBool;
public List<sbyte> ListInt8;
public List<byte> ListUInt8;
public List<ushort> ListUInt16;
public List<short> ListInt16;
public List<int> ListInt32;
public List<uint> ListUInt32;
public List<long> ListInt64;
public List<ulong> ListUInt64;
public List<float> ListFloat;
public List<double> ListDouble;
public List<string> 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<bool>;
binaryReader.ReadList(out var outListInt8);
allType.ListInt8 = outListInt8 as List<sbyte>;
binaryReader.ReadList(out var outListUInt8);
allType.ListUInt8 = outListUInt8 as List<byte>;
binaryReader.ReadList(out var outListUInt16);
allType.ListUInt16 = outListUInt16 as List<ushort>;
binaryReader.ReadList(out var outListInt16);
allType.ListInt16 = outListInt16 as List<short>;
binaryReader.ReadList(out var outListInt32);
allType.ListInt32 = outListInt32 as List<int>;
binaryReader.ReadList(out var outListUInt32);
allType.ListUInt32 = outListUInt32 as List<uint>;
binaryReader.ReadList(out var outListInt64);
allType.ListInt64 = outListInt64 as List<long>;
binaryReader.ReadList(out var outListUInt64);
allType.ListUInt64 = outListUInt64 as List<ulong>;
binaryReader.ReadList(out var outListFloat);
allType.ListFloat = outListFloat as List<float>;
binaryReader.ReadList(out var outListDouble);
allType.ListDouble = outListDouble as List<double>;
binaryReader.ReadList(out var outListString);
allType.ListString = outListString as List<string>;
return allType;
}
}
}

+ 0
- 148
src/writeCs/ProtocolReader.cs Wyświetl plik

@ -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;
}
}
}

+ 0
- 113
src/writeCs/ProtocolWriter.cs Wyświetl plik

@ -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]);
}
}
}

+ 193
- 0
src/writeCs/gCsCode.cs Wyświetl plik

@ -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>(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<T>(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<T>(this BinaryWriter binaryWriter, IList<T> 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<bool>(length);
var boolValue = binaryReader.ReadBoolean();
list.Add(boolValue);
break;
case BasicTypeEnum.Int8:
list ??= new List<sbyte>(length);
var sbyteValue = binaryReader.ReadSByte();
list.Add(sbyteValue);
break;
case BasicTypeEnum.UInt8:
list ??= new List<byte>(length);
var byteValue = binaryReader.ReadByte();
list.Add(byteValue);
break;
case BasicTypeEnum.UInt16:
list ??= new List<ushort>(length);
var ushortValue = binaryReader.ReadUInt16();
list.Add(ushortValue);
break;
case BasicTypeEnum.Int16:
list ??= new List<short>(length);
var shortValue = binaryReader.ReadInt16();
list.Add(shortValue);
break;
case BasicTypeEnum.Int32:
list ??= new List<int>(length);
var intValue = binaryReader.ReadInt32();
list.Add(intValue);
break;
case BasicTypeEnum.UInt32:
list ??= new List<uint>(length);
var uintValue = binaryReader.ReadUInt32();
list.Add(uintValue);
break;
case BasicTypeEnum.Int64:
list ??= new List<long>(length);
var longValue = binaryReader.ReadInt64();
list.Add(longValue);
break;
case BasicTypeEnum.UInt64:
list ??= new List<ulong>(length);
var ulongValue = binaryReader.ReadUInt64();
list.Add(ulongValue);
break;
case BasicTypeEnum.Float:
list ??= new List<float>(length);
var singleValue = binaryReader.ReadSingle();
list.Add(singleValue);
break;
case BasicTypeEnum.Double:
list ??= new List<double>(length);
var doubleValue = binaryReader.ReadDouble();
list.Add(doubleValue);
break;
case BasicTypeEnum.String:
list ??= new List<string>(length);
var stringValue = binaryReader.ReadString();
list.Add(stringValue);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
}
}

+ 99
- 0
src/writeCs/gCsField.erl Wyświetl plik

@ -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} ->
<<NameStr/binary, " = ", DefValueStr/binary, " :: ", DefTypeStr/binary, "\n">>;
_ ->
case TypeStr of
<<"list[", LeftStr/binary>> ->
[SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
case lists:keyfind(SubTypeStr, 1, ?TypeValue) of
{SubTypeStr, _DefSubValueStr, DefSubTypeStr} ->
<<NameStr/binary, " = [] :: [", DefSubTypeStr/binary, "]\n">>;
_ ->
<<NameStr/binary, " = [] :: [#", SubTypeStr/binary, "{}]\n">>
end;
_ ->
<<NameStr/binary, " = undefined :: #", TypeStr/binary, "{}\n">>
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).

+ 765
- 1
src/writeCs/gCsGen.erl Wyświetl plik

@ -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>(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<T>(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<T>(this BinaryWriter binaryWriter, IList<T> 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<bool>(length);
var boolValue = binaryReader.ReadBoolean();
list.Add(boolValue);
break;
case BasicTypeEnum.Int8:
list ??= new List<sbyte>(length);
var sbyteValue = binaryReader.ReadSByte();
list.Add(sbyteValue);
break;
case BasicTypeEnum.UInt8:
list ??= new List<byte>(length);
var byteValue = binaryReader.ReadByte();
list.Add(byteValue);
break;
case BasicTypeEnum.UInt16:
list ??= new List<ushort>(length);
var ushortValue = binaryReader.ReadUInt16();
list.Add(ushortValue);
break;
case BasicTypeEnum.Int16:
list ??= new List<short>(length);
var shortValue = binaryReader.ReadInt16();
list.Add(shortValue);
break;
case BasicTypeEnum.Int32:
list ??= new List<int>(length);
var intValue = binaryReader.ReadInt32();
list.Add(intValue);
break;
case BasicTypeEnum.UInt32:
list ??= new List<uint>(length);
var uintValue = binaryReader.ReadUInt32();
list.Add(uintValue);
break;
case BasicTypeEnum.Int64:
list ??= new List<long>(length);
var longValue = binaryReader.ReadInt64();
list.Add(longValue);
break;
case BasicTypeEnum.UInt64:
list ??= new List<ulong>(length);
var ulongValue = binaryReader.ReadUInt64();
list.Add(ulongValue);
break;
case BasicTypeEnum.Float:
list ??= new List<float>(length);
var singleValue = binaryReader.ReadSingle();
list.Add(singleValue);
break;
case BasicTypeEnum.Double:
list ??= new List<double>(length);
var doubleValue = binaryReader.ReadDouble();
list.Add(doubleValue);
break;
case BasicTypeEnum.String:
list ??= new List<string>(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 = <<TemStr/binary, (gErlField:builtRecStr(FieldInfo))/binary, (case Index == 1 of true -> <<"">>; _ -> <<"\t">> end)/binary>>,
genMsgHrl(FieldList, Index - 1, Len, <<HrlBinStr/binary, RecStr/binary>>).
spellHead([], _Index, HeadBinStr) ->
HeadBinStr;
spellHead([_FieldInfo | FieldList], Index, HeadBinStr) ->
spellHead(FieldList, Index + 1, <<HeadBinStr/binary, ", V", (integer_to_binary(Index))/binary>>).
spellBody([], _Index, BodyBinStr) ->
BodyBinStr;
spellBody([{FieldType, _FieldName}], Index, BodyBinStr) ->
TemV = <<"V", (integer_to_binary(Index))/binary>>,
<<BodyBinStr/binary, (gErlField:builtPackStr(FieldType))/binary, TemV/binary, ")">>;
spellBody([{FieldType, _FieldName} | FieldList], Index, BodyBinStr) ->
TemV = <<"V", (integer_to_binary(Index))/binary>>,
NewBodyBinStr = <<BodyBinStr/binary, (gErlField:builtPackStr(FieldType))/binary, TemV/binary, "), ">>,
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, <<ErrBinStr/binary, ErrStr/binary>>).
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 ->
<<HeadStr/binary, "[<<", (integer_to_binary(MsgId))/binary, ":16/big-unsigned>>, ", BodyStr/binary, "];\n">>;
_ ->
<<HeadStr/binary, "[<<", (integer_to_binary(MsgId))/binary, ":16/big-unsigned>>];\n">>
end;
_ ->
case FieldLen > 0 of
true ->
<<HeadStr/binary, "[", BodyStr/binary, "];\n">>;
_ ->
<<HeadStr/binary, "[];\n">>
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<<Bool", UseBoolStr/binary, ":8/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
UseVStr = useIndexStr(pd_v),
VStr = <<"\tV", UseVStr/binary, " = Bool", UseBoolStr/binary, " =:= 1,\n">>,
{false, <<StrAcc/binary, TemStr/binary, BoolStr/binary, VStr/binary>>};
<<"int8">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":8/big-signed, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":8/big-signed, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"uint8">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":8/big-unsigned, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":8/big-unsigned, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"int16">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":16/big-signed, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":16/big-signed, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"uint16">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":16/big-unsigned, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":16/big-unsigned, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"int32">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":32/big-signed, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":32/big-signed, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"uint32">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":32/big-unsigned, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":32/big-unsigned, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"int64">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":64/big-signed, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":64/big-signed, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"uint64">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":64/big-unsigned, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":64/big-unsigned, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"float">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":32/big-float, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":32/big-float, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"double">> ->
TemStr =
case IsSimple of
true ->
UseVStr = useIndexStr(pd_v),
<<"V", UseVStr/binary, ":64/big-float, ">>;
_ ->
UseVStr = useIndexStr(pd_v),
<<"\t<<V", UseVStr/binary, ":64/big-float, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"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<<Len", UseLenStr/binary, ":16/big-unsigned, TemStrV", UseVStr/binary, ":Len", UseLenStr/binary, "/binary, LeftBin", UseLeftBinStr2/binary, "/binary>> = 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, <<StrAcc/binary, TemStr/binary, RefSizeStr/binary, StrStr/binary, VStr/binary>>};
<<"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<<IntBits", UseIntBitsStr/binary, ":8, V", UseVStr/binary, ":IntBits", UseIntBitsStr/binary, "/big-signed, ">>
end,
{true, <<StrAcc/binary, TemStr/binary>>};
<<"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<<NumBits", UseNumBitsStr/binary, ":8, LeftBin", UseLeftBinStr2/binary, "/binary>> = 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<<V", UseVStr/binary, ":32/big-float, LeftBin", UseLeftBinStr3/binary,
"/binary>> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t65 ->\n\t\t\t<<V", UseVStr/binary, ":64/big-float, LeftBin", UseLeftBinStr3/binary,
"/binary>> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t_ ->\n\t\t\t<<V", UseVStr/binary, ":NumBits", UseNumBitsStr/binary, "/big-signed, LeftBin", UseLeftBinStr3/binary,
"/binary>> = LeftBin", UseLeftBinStr2/binary, "\n\tend,\n">>,
{false, <<StrAcc/binary, TemStr/binary, NumStr/binary, VStr/binary>>};
<<"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<<Len", UseLenStr/binary, ":16/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
DeListStr =
case SubTypeStr of
<<"bool">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV =:= 1 || <<TemV:8/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"int8">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:8/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"uint8">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:8/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"int16">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:16, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:16/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"uint16">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:16, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:16/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"int32">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"uint32">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"int64">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"uint64">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"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<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-float>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"double">> ->
ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-float>> <= ListBin", UseListBinStr/binary, "],\n">>,
<<ListBinStr/binary, VStr/binary>>;
<<"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">>,
<<RefSizeStr/binary, VStr/binary>>
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, <<StrAcc/binary, TemStr/binary, LenStr/binary, DeListStr/binary>>};
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<<IsUndef", UseIsUndefStr/binary, ":8/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = 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, <<StrAcc/binary, TemStr/binary, IsStr/binary, VStr/binary>>};
_ ->
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),
<<BodyStr/binary, "LeftBin", LUseLeftBinStr/binary, "/binary>> = 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 = <<ModName/binary, "Her">>,
case FieldLen > 0 of
true ->
FunRec =
fun(N, Acc) ->
<<Acc/binary, ", V", (integer_to_binary(N))/binary>>
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) ->
<<Acc/binary, ", V", (integer_to_binary(N))/binary>>
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,
<<HeadStr/binary, LBodyStr/binary, RetStr/binary>>.
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),
{<<MsgHrlAcc/binary, HrlStr/binary>>, <<MsgEncodeAcc/binary, EncodeStr/binary>>, <<MsgDecodeAcc/binary, DecodeStr/binary>>, <<MsgIdAcc/binary, IdStr/binary>>, <<MsgNameAcc/binary, NameStr/binary>>}
end,
{MsgHrlStr, TMsgEncodeStr, TMsgDecodeStr, _TMsgIdStr, _TMsgNameStr} = lists:foldl(FunSpell, {<<>>, <<>>, <<>>, <<>>, <<>>}, SortedSProtoList),
MsgEncodeStr = <<TMsgEncodeStr/binary, "encodeIol(_, _) ->\n\t[].\n\n">>,
MsgDecodeStr = <<TMsgDecodeStr/binary, "decodeBin(_, _) ->\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 = <<ErlHeaderStr/binary, MsgEncodeRecStr/binary, MsgEncodeStr/binary, MsgDecodeRecStr/binary, MsgDecodeStr/binary>>,
OutputHrlStr = <<HrlHeaderStr/binary, ErrCodeStr/binary, "\n\n", MsgHrlStr/binary>>,
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
[] ->
{<<SubEncodeAcc/binary, "subEncode(_, _) ->\n\t[].\n\n">>, <<SubDecodeAcc/binary, "decodeRec(_, _) ->\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, <<SubEncodeAcc/binary, EncodeStr/binary>>, <<SubDecodeAcc/binary, DecodeStr/binary>>).
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.

+ 0
- 676
src/writeCs/testExample.cs Wyświetl plik

@ -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<double> doubleArray_= new List<double>();
public List<float> floatArray_= new List<float>();
public List<long> int64Array_= new List<long>();
public List<ulong> uint64Array_= new List<ulong>();
public List<int> int32Array_= new List<int>();
public List<uint> uint32Array_= new List<uint>();
public List<short> int16Array_= new List<short>();
public List<ushort> uint16Array_= new List<ushort>();
public List<sbyte> int8Array_= new List<sbyte>();
public List<byte> uint8Array_= new List<byte>();
public List<bool> boolArray_= new List<bool>();
public List<string> strArray_= new List<string>();
public List<string> strArray1_= new List<string>();
public List<byte[]> binArray_= new List<byte[]>();
public List<byte[]> bin1Array_= new List<byte[]>();
public List<EnumName> enumArray_= new List<EnumName>();
public List<StructType> structArray_= new List<StructType>();
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);
}
}
}

Napisz Podgląd
Ładowanie…
Anuluj
Zapisz