private bool AddEnumMapItemDef(
ProtocolDescriptor.ProtocolDef protoDef,
ProtocolDescriptor.EnumMapDef enumMapDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(protoDef, element,
"`item` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(protoDef, element,
"`item` node `name` attribute is invalid");
return(false);
}
if (enumMapDef.ItemNameIndex.ContainsKey(name))
{
PrintLineError(protoDef, element,
"`item` node `name` attribute duplicated");
return(false);
}
// check value attr
string val = "";
{
XAttribute attr = element.Attribute("value");
if (attr != null)
{
val = attr.Value;
}
}
// check struct attr
string structVal = "";
{
XAttribute attr = element.Attribute("struct");
if (attr != null)
{
structVal = attr.Value;
}
}
ProtocolDescriptor.EnumMapDef.ItemDef def =
new ProtocolDescriptor.EnumMapDef.ItemDef();
def.ParentRef = enumMapDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
if (val == "")
{
// default
def.Type = ProtocolDescriptor.EnumMapDef.ItemType.Default;
if (enumMapDef.Items.Count == 0)
{
def.IntValue = 0;
}
else
{
def.IntValue = enumMapDef.Items[
enumMapDef.Items.Count - 1].IntValue + 1;
}
}
else if (Regex.IsMatch(val, @"^[0-9]+$"))
{
// int
def.Type = ProtocolDescriptor.EnumMapDef.ItemType.Int;
def.IntValue = int.TryParse(val, out def.IntValue)
? def.IntValue : 0;
}
else
{
// current enum
ProtocolDescriptor.EnumMapDef.ItemDef refDef = null;
if (enumMapDef.ItemNameIndex.TryGetValue(
val, out refDef) == false)
{
PrintLineError(protoDef, element,
"enum_map item `{0}` is undefined", val);
return(false);
}
def.Type =
ProtocolDescriptor.EnumMapDef.ItemType.CurrentEnumRef;
def.IntValue = refDef.IntValue;
def.RefEnumItemDef = refDef;
}
if (enumMapDef.Items.Count > 0 &&
def.IntValue < enumMapDef.Items[
enumMapDef.Items.Count - 1].IntValue)
{
PrintLineError(protoDef, element,
"`item` node `value` attribute can not be " +
"less than previous one");
return(false);
}
if (structVal != "")
{
ProtocolDescriptor.ProtocolDef refProtoDef = null;
string refDefName = "";
string[] parts = structVal.Split('.');
if (parts.Length == 1)
{
// in same file
refProtoDef = protoDef;
refDefName = parts[0];
}
else if (parts.Length == 2)
{
// in other file
string refProtoDefName = parts[0];
if (this.descriptor.ImportedProtos.TryGetValue(
refProtoDefName, out refProtoDef) == false)
{
PrintLineError(protoDef, element,
"protocol `{0}` is undefined", refProtoDefName);
return(false);
}
refDefName = parts[1];
}
else
{
PrintLineError(protoDef, element,
"struct `{0}` is invalid", structVal);
return(false);
}
ProtocolDescriptor.StructDef refStructDef = null;
if (refProtoDef.StructNameIndex.TryGetValue(
refDefName, out refStructDef) == false)
{
PrintLineError(protoDef, element,
"struct `{0}` is undefined", refDefName);
return(false);
}
def.RefStructDef = refStructDef;
if (enumMapDef.IdToStructIndex.ContainsKey(def.IntValue))
{
PrintLineError(protoDef, element,
"id `{0}` is already mapped to a struct",
def.IntValue);
return(false);
}
if (enumMapDef.StructToIdIndex.ContainsKey(def.RefStructDef))
{
PrintLineError(protoDef, element,
"struct `{0}` is already mapped to a id",
def.RefStructDef.Name);
return(false);
}
enumMapDef.IdToStructIndex.Add(def.IntValue, def.RefStructDef);
enumMapDef.StructToIdIndex.Add(def.RefStructDef, def.IntValue);
}
enumMapDef.Items.Add(def);
enumMapDef.ItemNameIndex.Add(def.Name, def);
return(true);
}
private bool AddStructDef(
ProtocolDescriptor.ProtocolDef protoDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(protoDef, element,
"`struct` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(protoDef, element,
"`struct` node `name` attribute is invalid");
return(false);
}
if (protoDef.StructNameIndex.ContainsKey(name) ||
protoDef.EnumNameIndex.ContainsKey(name) ||
protoDef.EnumMapNameIndex.ContainsKey(name))
{
PrintLineError(protoDef, element,
"`struct` node `name` attribute duplicated");
return(false);
}
ProtocolDescriptor.StructDef def =
new ProtocolDescriptor.StructDef();
def.ParentRef = protoDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
// parse fields
{
IEnumerator <XElement> iter =
element.Elements().GetEnumerator();
while (iter.MoveNext())
{
XElement childElement = iter.Current;
if (childElement.Name != "required" &&
childElement.Name != "optional")
{
PrintLineError(protoDef, childElement,
"expect a `required` or `optional` node");
return(false);
}
if (AddStructFieldDef(protoDef, def,
childElement) == false)
{
return(false);
}
}
}
if (def.OptionalFieldCount > 0)
{
def.OptionalByteCount =
(def.OptionalFieldCount - 1) / 8 + 1;
}
protoDef.Structs.Add(def);
protoDef.StructNameIndex.Add(def.Name, def);
return(true);
}
private bool AddStructFieldDef(
ProtocolDescriptor.ProtocolDef protoDef,
ProtocolDescriptor.StructDef structDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(protoDef, element,
"`{0}` node must contain a `name` attribute",
element.Name);
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(protoDef, element,
"`{0}` node `name` attribute is invalid",
element.Name);
return(false);
}
if (structDef.FieldNameIndex.ContainsKey(name))
{
PrintLineError(protoDef, element,
"`{0}` node `name` attribute duplicated",
element.Name);
return(false);
}
// check type attr
string type;
{
XAttribute attr = element.Attribute("type");
if (attr == null)
{
PrintLineError(protoDef, element,
"`{0}` node must contain a `type` attribute",
element.Name);
return(false);
}
type = attr.Value;
}
ProtocolDescriptor.StructDef.FieldDef def =
new ProtocolDescriptor.StructDef.FieldDef();
def.ParentRef = structDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
// get type info
string fieldTypeStr = type;
{
Match m = Regex.Match(type, @"^list{(.+)}$");
if (m.Success)
{
fieldTypeStr = m.Groups[1].Value;
def.Type = ProtocolDescriptor.StructDef.FieldType.List;
}
}
ProtocolDescriptor.StructDef.FieldType fieldType =
ProtocolDescriptor.StructDef.FieldType.None;
if (fieldTypeStr == "i8")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I8;
}
else if (fieldTypeStr == "u8")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U8;
}
else if (fieldTypeStr == "i16")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I16;
}
else if (fieldTypeStr == "u16")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U16;
}
else if (fieldTypeStr == "i32")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I32;
}
else if (fieldTypeStr == "u32")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U32;
}
else if (fieldTypeStr == "i64")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I64;
}
else if (fieldTypeStr == "u64")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U64;
}
else if (fieldTypeStr == "i16v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I16V;
}
else if (fieldTypeStr == "u16v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U16V;
}
else if (fieldTypeStr == "i32v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I32V;
}
else if (fieldTypeStr == "u32v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U32V;
}
else if (fieldTypeStr == "i64v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.I64V;
}
else if (fieldTypeStr == "u64v")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.U64V;
}
else if (fieldTypeStr == "string")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.String;
}
else if (fieldTypeStr == "bytes")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.Bytes;
}
else if (fieldTypeStr == "bool")
{
fieldType = ProtocolDescriptor.StructDef.FieldType.Bool;
}
else
{
ProtocolDescriptor.ProtocolDef refProtoDef = null;
string refDefName = "";
string[] parts = fieldTypeStr.Split('.');
if (parts.Length == 1)
{
// in same file
refProtoDef = protoDef;
refDefName = parts[0];
}
else if (parts.Length == 2)
{
// in other file
string refProtoDefName = parts[0];
if (this.descriptor.ImportedProtos.TryGetValue(
refProtoDefName, out refProtoDef) == false)
{
PrintLineError(protoDef, element,
"protocol `{0}` is undefined", refProtoDefName);
return(false);
}
refDefName = parts[1];
}
else
{
PrintLineError(protoDef, element,
"type `{0}` is invalid", fieldTypeStr);
return(false);
}
for (;;)
{
// check is enum
ProtocolDescriptor.EnumDef refEnumDef = null;
if (refProtoDef.EnumNameIndex.TryGetValue(
refDefName, out refEnumDef))
{
fieldType = ProtocolDescriptor.StructDef.FieldType.Enum;
def.RefEnumDef = refEnumDef;
break;
}
// check is struct
ProtocolDescriptor.StructDef refStructDef = null;
if (refProtoDef.StructNameIndex.TryGetValue(
refDefName, out refStructDef))
{
fieldType = ProtocolDescriptor.StructDef.FieldType.Struct;
def.RefStructDef = refStructDef;
break;
}
PrintLineError(protoDef, element,
"type `{0}` is undefined", refDefName);
return(false);
}
}
if (def.Type == ProtocolDescriptor.StructDef.FieldType.List)
{
def.ListType = fieldType;
}
else
{
def.Type = fieldType;
}
// optional
if (element.Name == "optional")
{
def.IsOptional = true;
def.OptionalFieldIndex = structDef.OptionalFieldCount++;
}
structDef.Fields.Add(def);
structDef.FieldNameIndex.Add(def.Name, def);
return(true);
}
private void ProcessImportedProtocols(
ProtocolDescriptor.ProtocolDef protoDef)
{
Dictionary <string, ProtocolDescriptor.ProtocolDef> usedProtos =
new Dictionary <string, ProtocolDescriptor.ProtocolDef>();
Dictionary <string, ProtocolDescriptor.ProtocolDef> enumRefProtos =
new Dictionary <string, ProtocolDescriptor.ProtocolDef>();
Dictionary <string, ProtocolDescriptor.ProtocolDef> structRefProtos =
new Dictionary <string, ProtocolDescriptor.ProtocolDef>();
Dictionary <string, ProtocolDescriptor.ProtocolDef> enumMapRefProtos =
new Dictionary <string, ProtocolDescriptor.ProtocolDef>();
// collect enum ref protocols
for (int i = 0; i < protoDef.Enums.Count; ++i)
{
ProtocolDescriptor.EnumDef enumDef =
protoDef.Enums[i];
for (int j = 0; j < enumDef.Items.Count; ++j)
{
ProtocolDescriptor.EnumDef.ItemDef def =
enumDef.Items[j];
if (def.RefEnumItemDef != null)
{
ProtocolDescriptor.ProtocolDef refProtoDef =
def.RefEnumItemDef.ParentRef.ParentRef;
usedProtos[refProtoDef.Name] = refProtoDef;
enumRefProtos[refProtoDef.Name] = refProtoDef;
}
}
}
// collect struct ref protocols
for (int i = 0; i < protoDef.Structs.Count; ++i)
{
ProtocolDescriptor.StructDef structDef =
protoDef.Structs[i];
for (int j = 0; j < structDef.Fields.Count; ++j)
{
ProtocolDescriptor.StructDef.FieldDef def =
structDef.Fields[j];
if (def.RefEnumDef != null)
{
ProtocolDescriptor.ProtocolDef refProtoDef =
def.RefEnumDef.ParentRef;
usedProtos[refProtoDef.Name] = refProtoDef;
structRefProtos[refProtoDef.Name] = refProtoDef;
}
if (def.RefStructDef != null)
{
ProtocolDescriptor.ProtocolDef refProtoDef =
def.RefStructDef.ParentRef;
usedProtos[refProtoDef.Name] = refProtoDef;
structRefProtos[refProtoDef.Name] = refProtoDef;
}
}
}
// collect enum map ref protocols
for (int i = 0; i < protoDef.EnumMaps.Count; ++i)
{
ProtocolDescriptor.EnumMapDef enumMapDef =
protoDef.EnumMaps[i];
for (int j = 0; j < enumMapDef.Items.Count; ++j)
{
ProtocolDescriptor.EnumMapDef.ItemDef def =
enumMapDef.Items[j];
if (def.RefEnumItemDef != null)
{
ProtocolDescriptor.ProtocolDef refProtoDef =
def.RefEnumItemDef.ParentRef.ParentRef;
usedProtos[refProtoDef.Name] = refProtoDef;
enumMapRefProtos[refProtoDef.Name] = refProtoDef;
}
if (def.RefStructDef != null)
{
ProtocolDescriptor.ProtocolDef refProtoDef =
def.RefStructDef.ParentRef;
usedProtos[refProtoDef.Name] = refProtoDef;
enumMapRefProtos[refProtoDef.Name] = refProtoDef;
}
}
}
for (int i = 0; i < protoDef.Imports.Count; ++i)
{
ProtocolDescriptor.ImportDef importDef =
protoDef.Imports[i];
// check imported protocol is used
if (usedProtos.ContainsKey(importDef.ProtoDef.Name) == false)
{
Console.Error.WriteLine(string.Format(
"warning:{0}:{1}: protocol `{2}` " +
"is not used but imported",
protoDef.FilePath, importDef.LineNumber,
importDef.Name));
}
if (enumRefProtos.ContainsKey(importDef.ProtoDef.Name))
{
importDef.IsRefByEnum = true;
}
if (structRefProtos.ContainsKey(importDef.ProtoDef.Name))
{
importDef.IsRefByStruct = true;
}
if (enumMapRefProtos.ContainsKey(importDef.ProtoDef.Name))
{
importDef.IsRefByEnumMap = true;
}
}
}