SisMaker
/
genProto
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Projects 0 Релизы 3 Вики Активность
Просмотр исходного кода

ft: lua cs示例代码添加

master
SisMaker 4 лет назад
Родитель
533cbd1a06
Сommit
8f87f1b060
12 измененных файлов: 2472 добавлений и 0 удалений
Единый вид
Опции Diff
Показать статистику Скачать Patch файл Скачать Diff файл
  1. +106
    -0
      proto/Example.btk
  2. +214
    -0
      src/writeCs/CSGenerator.cpp
  3. +13
    -0
      src/writeCs/IReader.cs
  4. +9
    -0
      src/writeCs/IWriter.cs
  5. +148
    -0
      src/writeCs/ProtocolReader.cs
  6. +113
    -0
      src/writeCs/ProtocolWriter.cs
  7. +676
    -0
      src/writeCs/testExample.cs
  8. +562
    -0
      src/writeLua/Example.lua
  9. +161
    -0
      src/writeLua/LUAGenerator.cpp
  10. +189
    -0
      src/writeLua/reader.lua
  11. +111
    -0
      src/writeLua/types.lua
  12. +170
    -0
      src/writeLua/writer.lua

+ 106
- 0
proto/Example.btk Просмотреть файл

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

+ 214
- 0
src/writeCs/CSGenerator.cpp Просмотреть файл

@ -0,0 +1,214 @@
#include "Options.h"
#include "Context.h"
#include "CodeFile.h"
#include "CodeGenerator.h"
DECLARE_CG(CSGenerator, cs);
static void generateEnum(CodeFile& f, Enum* e)
{
f.output("public enum %s : %s", e->getNameC(), e->isEnum16()?"ushort":"byte");
f.indent("{");
for(size_t i = 0; i < e->items_.size(); i++)
f.output("%s,", e->items_[i].c_str());
f.recover("}");
f.output("namespace bintalk");
f.indent("{");
f.output("public static partial class ProtocolReader");
f.indent("{");
f.output("public static bool read(bintalk.IReader r, ref %s v, uint maxValue)", e->getNameC());
f.indent("{");
f.output("%s e = 0;", e->isEnum16()?"ushort":"byte");
f.output("if(!read(r, ref e, 0)) return false;");
f.output("v = (%s)e;", e->getNameC());
f.output("return true;");
f.recover("}");
f.recover("}");
f.output("public static partial class ProtocolWriter");
f.indent("{");
f.output("public static void write(bintalk.IWriter w, %s v)", e->getNameC());
f.indent("{");
f.output("write(w, (%s)v);", e->isEnum16()?"ushort":"byte");
f.recover("}");
f.recover("}");
f.recover("}");
}
static const char* getFieldInnerTypeName(Field& f)
{
switch(f.type_)
{
case Field::FT_INT64: return "long";
case Field::FT_UINT64: return "ulong";
case Field::FT_DOUBLE: return "double";
case Field::FT_FLOAT: return "float";
case Field::FT_INT32: return "int";
case Field::FT_UINT32: return "uint";
case Field::FT_INT16: return "short";
case Field::FT_UINT16: return "ushort";
case Field::FT_INT8: return "sbyte";
case Field::FT_UINT8: return "byte";
case Field::FT_BOOL: return "bool";
case Field::FT_STRING: return "string";
case Field::FT_BINARY: return "byte[]";
case Field::FT_USER:
case Field::FT_ENUM: return f.userType_->getNameC();
}
return NULL;
}
static void getFieldTypeName(Field& f, std::string& name)
{
name = getFieldInnerTypeName(f);
if(f.isArray())
name = "List<" + name + ">";
}
static void getFieldInnerDefault(Field& f, std::string& name)
{
switch(f.type_)
{
case Field::FT_INT64:
case Field::FT_UINT64:
case Field::FT_DOUBLE:
case Field::FT_FLOAT:
case Field::FT_INT32:
case Field::FT_UINT32:
case Field::FT_INT16:
case Field::FT_UINT16:
case Field::FT_INT8:
case Field::FT_UINT8: name = "0"; break;
case Field::FT_BOOL: name = "false"; break;
case Field::FT_STRING: name = "\"\""; break;
case Field::FT_BINARY: name = "new byte[0]"; break;
case Field::FT_USER: name = "new "; name += f.userType_->name_; name += "()"; break;
case Field::FT_ENUM: name = "("; name += f.userType_->name_; name += ")(0)"; break;
}
}
static void getFieldDefault(Field& f, std::string& name)
{
if(f.isArray())
{
name = "new ";
std::string tn;
getFieldTypeName(f, tn);
name += tn;
name += "()";
}
else
getFieldInnerDefault(f, name);
}
static void generateFieldSCode(CodeFile& f, Field& field)
{
if(field.isArray())
{
f.indent("{");
f.output("bintalk.ProtocolWriter.writeDynSize(__w__, (uint)%s.Count);", field.getNameC());
f.output("foreach(%s __vi__ in %s) bintalk.ProtocolWriter.write(__w__, __vi__);",
getFieldInnerTypeName(field),
field.getNameC());
f.recover("}");
}
else
f.output("bintalk.ProtocolWriter.write(__w__, %s);", field.getNameC());
}
static void generateFieldContainerSCode(CodeFile& f, FieldContainer* fc)
{
for(size_t i = 0; i < fc->fields_.size(); i++)
generateFieldSCode(f, fc->fields_[i]);
}
static void generateFieldDSCode(CodeFile& f, Field& field)
{
if(field.isArray())
{
f.indent("{");
f.output("uint __s__;");
f.output("if (!bintalk.ProtocolReader.readDynSize(__r__, out __s__) || __s__ > 0X%X) return false;", field.maxArray_);
f.output("for(uint __i__ = 0; __i__ < __s__; __i__++)");
f.indent("{");
std::string idft;
getFieldInnerDefault(field, idft);
f.output("%s __vi__ = %s;", getFieldInnerTypeName(field), idft.c_str());
f.output("if (!bintalk.ProtocolReader.read(__r__, ref __vi__, 0X%X)) return false;", field.maxValue_);
f.output("%s.Add(__vi__);", field.getNameC());
f.recover("}");
f.recover("}");
}
else
f.output("if(!bintalk.ProtocolReader.read(__r__, ref %s, 0X%X)) return false;", field.getNameC(), field.maxValue_);
}
static void generateFieldContainerDSCode(CodeFile& f, FieldContainer* fc)
{
for(size_t i = 0; i < fc->fields_.size(); i++)
generateFieldDSCode(f, fc->fields_[i]);
}
static void generateStruct(CodeFile& f, Struct* s)
{
f.output("public class %s", s->getNameC());
f.indent("{");
// fields.
for(size_t i = 0; i < s->fields_.size(); i++)
{
Field& field = s->fields_[i];
std::string tn;
getFieldTypeName(field, tn);
std::string dft;
getFieldDefault(field, dft);
f.output("public %s %s= %s;",
tn.c_str(),
field.getNameC(),
dft.c_str());
}
// serialize code.
f.output("public void serialize(bintalk.IWriter __w__)");
f.indent("{");
generateFieldContainerSCode(f, s);
f.recover("}");
// deserialize code.
f.output("public bool deserialize(bintalk.IReader __r__)");
f.indent("{");
generateFieldContainerDSCode(f, s);
f.output("return true;");
f.recover("}");
f.recover("}");
////////////////////////////////////////////////////////////////////////////////
f.output("namespace bintalk");
f.indent("{");
f.output("public static partial class ProtocolReader");
f.indent("{");
f.output("public static bool read(bintalk.IReader r, ref %s v, uint maxValue)", s->getNameC());
f.indent("{");
f.output("return v.deserialize(r);");
f.recover("}");
f.recover("}");
f.output("public static partial class ProtocolWriter");
f.indent("{");
f.output("public static void write(bintalk.IWriter w, %s v)", s->getNameC());
f.indent("{");
f.output("v.serialize(w);");
f.recover("}");
f.recover("}");
f.recover("}");
}
void CSGenerator::generate()
{
CodeFile f(gOptions.output_ + gOptions.inputFS_ + ".cs");
f.output("using System.Collections.Generic;");
for(size_t i = 0; i < gContext.definitions_.size(); i++)
{
Definition* definition = gContext.definitions_[i];
if(definition->file_ != gOptions.inputFN_)
continue;
if (definition->getEnum())
generateEnum(f, definition->getEnum());
else if (definition->getStruct())
generateStruct(f, definition->getStruct());
}
}

+ 13
- 0
src/writeCs/IReader.cs Просмотреть файл

@ -0,0 +1,13 @@
namespace bintalk
{
/** Abstract interface for reading binary data. */
public interface IReader
{
/**
* @param size data size want to read.
* @param[out] data buffer.
* @param[out] data buffer start id.
*/
bool read(uint size, out byte[] data, out int startId);
}
}

+ 9
- 0
src/writeCs/IWriter.cs Просмотреть файл

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

+ 148
- 0
src/writeCs/ProtocolReader.cs Просмотреть файл

@ -0,0 +1,148 @@
using System;
using System.Text;
using System.Collections.Generic;
namespace bintalk
{
/** This class can read basic types by using a bintalk.IReader object. */
public static partial class ProtocolReader
{
public static bool readMid(bintalk.IReader r, ref ushort v)
{
return read(r, ref v, 0);
}
// int64
public static bool read(bintalk.IReader r, ref long v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(8, out data, out startId)) return false;
v = BitConverter.ToInt64(data, startId);
return true;
}
// uint64
public static bool read(bintalk.IReader r, ref ulong v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(8, out data, out startId)) return false;
v = BitConverter.ToUInt64(data, startId);
return true;
}
// double
public static bool read(bintalk.IReader r, ref double v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(8, out data, out startId)) return false;
v = BitConverter.ToDouble(data, startId);
return true;
}
// float
public static bool read(bintalk.IReader r, ref float v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(4, out data, out startId)) return false;
v = BitConverter.ToSingle(data, startId);
return true;
}
// int32
public static bool read(bintalk.IReader r, ref int v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(4, out data, out startId)) return false;
v = BitConverter.ToInt32(data, startId);
return true;
}
// uint32
public static bool read(bintalk.IReader r, ref uint v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(4, out data, out startId)) return false;
v = BitConverter.ToUInt32(data, startId);
return true;
}
// int16
public static bool read(bintalk.IReader r, ref short v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(2, out data, out startId)) return false;
v = BitConverter.ToInt16(data, startId);
return true;
}
// uint16
public static bool read(bintalk.IReader r, ref ushort v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(2, out data, out startId)) return false;
v = BitConverter.ToUInt16(data, startId);
return true;
}
// int8
public static bool read(bintalk.IReader r, ref sbyte v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(1, out data, out startId))
return false;
v = (sbyte)data[startId];
return true;
}
// uint8
public static bool read(bintalk.IReader r, ref byte v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(1, out data, out startId))
return false;
v = data[startId];
return true;
}
// bool
public static bool read(bintalk.IReader r, ref bool v, uint maxValue)
{
byte[] data; int startId;
if (!r.read(1, out data, out startId))
return false;
v = (data[startId] == 0)?false:true;
return true;
}
// string.
public static bool read(bintalk.IReader r, ref string v, uint maxValue)
{
uint s;
if (!readDynSize(r, out s) || s > maxValue)
return false;
byte[] data; int startId;
if(!r.read(s, out data, out startId))
return false;
v = Encoding.UTF8.GetString(data, startId, (int)s);
return true;
}
// binary.
public static bool read(bintalk.IReader r, ref byte[] v, uint maxValue)
{
uint s;
if (!readDynSize(r, out s) || s > maxValue)
return false;
v = new byte[s];
byte[] data; int startId;
if(!r.read(s, out data, out startId))
return false;
Array.Copy(data, startId, v, 0, s);
return true;
}
// dynamic size.
public static bool readDynSize(bintalk.IReader r, out uint s)
{
s = 0;
byte b = 0;
if (!read(r, ref b, 0))
return false;
uint n = (uint)((b & 0XC0) >> 6);
s = (uint)(b & 0X3F);
for (int i = 0; i < n; i++)
{
if (!read(r, ref b, 0))
return false;
s = (s << 8) | b;
}
return true;
}
}
}

+ 113
- 0
src/writeCs/ProtocolWriter.cs Просмотреть файл

@ -0,0 +1,113 @@
using System;
using System.Text;
using System.Collections.Generic;
namespace bintalk
{
/** This class can write basic types by using a bintalk.IWriter object. */
public static partial class ProtocolWriter
{
public static void writeMid(bintalk.IWriter w, int v)
{
write(w, (ushort)v);
}
// int 64
public static void write(bintalk.IWriter w, long v)
{
w.write(BitConverter.GetBytes(v));
}
// uint64
public static void write(bintalk.IWriter w, ulong v)
{
w.write(BitConverter.GetBytes(v));
}
// double
public static void write(bintalk.IWriter w, double v)
{
w.write(BitConverter.GetBytes(v));
}
// float
public static void write(bintalk.IWriter w, float v)
{
w.write(BitConverter.GetBytes(v));
}
// int32
public static void write(bintalk.IWriter w, int v)
{
w.write(BitConverter.GetBytes(v));
}
// uint32
public static void write(bintalk.IWriter w, uint v)
{
w.write(BitConverter.GetBytes(v));
}
// int16
public static void write(bintalk.IWriter w, short v)
{
w.write(BitConverter.GetBytes(v));
}
// uint16
public static void write(bintalk.IWriter w, ushort v)
{
w.write(BitConverter.GetBytes(v));
}
// int8
public static void write(bintalk.IWriter w, sbyte v)
{
w.write(new byte[1]{(byte)v});
}
// uint8
public static void write(bintalk.IWriter w, byte v)
{
w.write(new byte[1]{v});
}
// bool
public static void write(bintalk.IWriter w, bool v)
{
write(w, (byte)(v?1:0));
}
// string
public static void write(bintalk.IWriter w, string v)
{
if (v == null || v.Length == 0)
writeDynSize(w, 0);
else
{
byte[] str = Encoding.UTF8.GetBytes(v);
uint len = (uint)str.Length;
writeDynSize(w, len);
if (len > 0)
w.write(str);
}
}
// binary.
public static void write(bintalk.IWriter w, byte[] v)
{
if (v == null || v.Length == 0)
writeDynSize(w, 0);
else
{
uint s = (uint)v.Length;
writeDynSize(w, s);
w.write(v);
}
}
// dynamic size.
public static void writeDynSize(bintalk.IWriter w, uint s)
{
byte[] b = BitConverter.GetBytes(s);
int n = 0;
if (s <= 0X3F)
n = 0;
else if (s <= 0X3FFF)
n = 1;
else if(s <= 0X3FFFFF)
n = 2;
else if(s <= 0X3FFFFFFF)
n = 3;
b[n] |= (byte)(n << 6);
for(int i = n; i >= 0; i--)
write(w, b[i]);
}
}
}

+ 676
- 0
src/writeCs/testExample.cs Просмотреть файл

@ -0,0 +1,676 @@
using System.Collections.Generic;
public enum EnumName : byte
{
EN1,
EN2,
EN3,
}
namespace bintalk
{
public static partial class ProtocolReader
{
public static bool read(bintalk.IReader r, ref EnumName v, uint maxValue)
{
byte e = 0;
if(!read(r, ref e, 0)) return false;
v = (EnumName)e;
return true;
}
}
public static partial class ProtocolWriter
{
public static void write(bintalk.IWriter w, EnumName v)
{
write(w, (byte)v);
}
}
}
public enum EnumName16 : ushort
{
EN16_a01,
EN16_a02,
EN16_a03,
EN16_a04,
EN16_a05,
EN16_a06,
EN16_a07,
EN16_a08,
EN16_a11,
EN16_a12,
EN16_a13,
EN16_a14,
EN16_a15,
EN16_a16,
EN16_a17,
EN16_a18,
EN16_a21,
EN16_a22,
EN16_a23,
EN16_a24,
EN16_a25,
EN16_a26,
EN16_a27,
EN16_a28,
EN16_a31,
EN16_a32,
EN16_a33,
EN16_a34,
EN16_a35,
EN16_a36,
EN16_a37,
EN16_a38,
EN16_a41,
EN16_a42,
EN16_a43,
EN16_a44,
EN16_a45,
EN16_a46,
EN16_a47,
EN16_a48,
EN16_a51,
EN16_a52,
EN16_a53,
EN16_a54,
EN16_a55,
EN16_a56,
EN16_a57,
EN16_a58,
EN16_a61,
EN16_a62,
EN16_a63,
EN16_a64,
EN16_a65,
EN16_a66,
EN16_a67,
EN16_a68,
EN16_a71,
EN16_a72,
EN16_a73,
EN16_a74,
EN16_a75,
EN16_a76,
EN16_a77,
EN16_a78,
EN16_b01,
EN16_b02,
EN16_b03,
EN16_b04,
EN16_b05,
EN16_b06,
EN16_b07,
EN16_b08,
EN16_b11,
EN16_b12,
EN16_b13,
EN16_b14,
EN16_b15,
EN16_b16,
EN16_b17,
EN16_b18,
EN16_b21,
EN16_b22,
EN16_b23,
EN16_b24,
EN16_b25,
EN16_b26,
EN16_b27,
EN16_b28,
EN16_b31,
EN16_b32,
EN16_b33,
EN16_b34,
EN16_b35,
EN16_b36,
EN16_b37,
EN16_b38,
EN16_b41,
EN16_b42,
EN16_b43,
EN16_b44,
EN16_b45,
EN16_b46,
EN16_b47,
EN16_b48,
EN16_b51,
EN16_b52,
EN16_b53,
EN16_b54,
EN16_b55,
EN16_b56,
EN16_b57,
EN16_b58,
EN16_b61,
EN16_b62,
EN16_b63,
EN16_b64,
EN16_b65,
EN16_b66,
EN16_b67,
EN16_b68,
EN16_b71,
EN16_b72,
EN16_b73,
EN16_b74,
EN16_b75,
EN16_b76,
EN16_b77,
EN16_b78,
EN16_c01,
EN16_c02,
EN16_c03,
EN16_c04,
EN16_c05,
EN16_c06,
EN16_c07,
EN16_c08,
EN16_c11,
EN16_c12,
EN16_c13,
EN16_c14,
EN16_c15,
EN16_c16,
EN16_c17,
EN16_c18,
EN16_c21,
EN16_c22,
EN16_c23,
EN16_c24,
EN16_c25,
EN16_c26,
EN16_c27,
EN16_c28,
EN16_c31,
EN16_c32,
EN16_c33,
EN16_c34,
EN16_c35,
EN16_c36,
EN16_c37,
EN16_c38,
EN16_c41,
EN16_c42,
EN16_c43,
EN16_c44,
EN16_c45,
EN16_c46,
EN16_c47,
EN16_c48,
EN16_c51,
EN16_c52,
EN16_c53,
EN16_c54,
EN16_c55,
EN16_c56,
EN16_c57,
EN16_c58,
EN16_c61,
EN16_c62,
EN16_c63,
EN16_c64,
EN16_c65,
EN16_c66,
EN16_c67,
EN16_c68,
EN16_c71,
EN16_c72,
EN16_c73,
EN16_c74,
EN16_c75,
EN16_c76,
EN16_c77,
EN16_c78,
EN16_d01,
EN16_d02,
EN16_d03,
EN16_d04,
EN16_d05,
EN16_d06,
EN16_d07,
EN16_d08,
EN16_d11,
EN16_d12,
EN16_d13,
EN16_d14,
EN16_d15,
EN16_d16,
EN16_d17,
EN16_d18,
EN16_d21,
EN16_d22,
EN16_d23,
EN16_d24,
EN16_d25,
EN16_d26,
EN16_d27,
EN16_d28,
EN16_d31,
EN16_d32,
EN16_d33,
EN16_d34,
EN16_d35,
EN16_d36,
EN16_d37,
EN16_d38,
EN16_d41,
EN16_d42,
EN16_d43,
EN16_d44,
EN16_d45,
EN16_d46,
EN16_d47,
EN16_d48,
EN16_d51,
EN16_d52,
EN16_d53,
EN16_d54,
EN16_d55,
EN16_d56,
EN16_d57,
EN16_d58,
EN16_d61,
EN16_d62,
EN16_d63,
EN16_d64,
EN16_d65,
EN16_d66,
EN16_d67,
EN16_d68,
EN16_d71,
EN16_d72,
EN16_d73,
EN16_d74,
EN16_d75,
EN16_d76,
EN16_d77,
EN16_d78,
Max,
}
namespace bintalk
{
public static partial class ProtocolReader
{
public static bool read(bintalk.IReader r, ref EnumName16 v, uint maxValue)
{
ushort e = 0;
if(!read(r, ref e, 0)) return false;
v = (EnumName16)e;
return true;
}
}
public static partial class ProtocolWriter
{
public static void write(bintalk.IWriter w, EnumName16 v)
{
write(w, (ushort)v);
}
}
}
public class StructType
{
public string aaa_= "";
public int bbb_= 0;
public void serialize(bintalk.IWriter __w__)
{
bintalk.ProtocolWriter.write(__w__, aaa_);
bintalk.ProtocolWriter.write(__w__, bbb_);
}
public bool deserialize(bintalk.IReader __r__)
{
if(!bintalk.ProtocolReader.read(__r__, ref aaa_, 0XFFFFFFFF)) return false;
if(!bintalk.ProtocolReader.read(__r__, ref bbb_, 0X0)) return false;
return true;
}
}
namespace bintalk
{
public static partial class ProtocolReader
{
public static bool read(bintalk.IReader r, ref StructType v, uint maxValue)
{
return v.deserialize(r);
}
}
public static partial class ProtocolWriter
{
public static void write(bintalk.IWriter w, StructType v)
{
v.serialize(w);
}
}
}
public class StructBase
{
public double double_= 0;
public float float_= 0;
public long int64_= 0;
public ulong uint64_= 0;
public int int32_= 0;
public uint uint32_= 0;
public short int16_= 0;
public ushort uint16_= 0;
public sbyte int8_= 0;
public byte uint8_= 0;
public bool bool_= false;
public EnumName enum_= (EnumName)(0);
public EnumName16 enum16_= (EnumName16)(0);
public StructType struct_= new StructType();
public string string_= "";
public string string1_= "";
public byte[] bin_= new byte[0];
public byte[] bin1_= new byte[0];
public List<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);
}
}
}

+ 562
- 0
src/writeLua/Example.lua Просмотреть файл

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

+ 161
- 0
src/writeLua/LUAGenerator.cpp Просмотреть файл

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

+ 189
- 0
src/writeLua/reader.lua Просмотреть файл

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

+ 111
- 0
src/writeLua/types.lua Просмотреть файл

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

+ 170
- 0
src/writeLua/writer.lua Просмотреть файл

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

Редактирование Предпросмотр
Загрузка…
Отмена
Сохранить