private void PrintLineError(
ProtocolDescriptor.ProtocolDef protoDef, XElement element,
string format, params object[] args)
{
PrintLineError(protoDef.FilePath, GetLineNumber(element),
format, args);
}
private bool AddNamespaceDef(
ProtocolDescriptor.ProtocolDef protoDef, XElement element)
{
// check lang attr
string lang;
{
XAttribute attr = element.Attribute("lang");
if (attr == null)
{
PrintLineError(protoDef, element,
"`namespace` node must contain a `lang` attribute");
return(false);
}
lang = attr.Value;
}
if (protoDef.Namespaces.ContainsKey(lang))
{
PrintLineError(protoDef, element,
"`namespace` node `lang` attribute duplicated");
return(false);
}
// check namespace value
if (element.Value == "")
{
PrintLineError(protoDef, element,
"`namespace` node value can not be empty");
return(false);
}
// check namespace parts
string[] namespaceParts = element.Value.Split('.');
for (int i = 0; i < namespaceParts.Length; ++i)
{
if (Regex.IsMatch(namespaceParts[i],
@"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(protoDef, element,
"`namespace` node value is invalid");
return(false);
}
}
ProtocolDescriptor.NamespaceDef def =
new ProtocolDescriptor.NamespaceDef();
def.ParentRef = protoDef;
def.Language = lang;
def.LineNumber = GetLineNumber(element);
def.Namespace = element.Value;
for (int i = 0; i < namespaceParts.Length; ++i)
{
def.NamespaceParts.Add(namespaceParts[i]);
}
protoDef.Namespaces.Add(def.Language, def);
return(true);
}
private bool AddImportDef(
ProtocolDescriptor.ProtocolDef protoDef, XElement element,
ProtocolDescriptor.ProtocolDef externalProtoDef)
{
ProtocolDescriptor.ImportDef def =
new ProtocolDescriptor.ImportDef();
def.ParentRef = protoDef;
def.Name = externalProtoDef.Name;
def.LineNumber = GetLineNumber(element);
def.ProtoDef = externalProtoDef;
if (protoDef.ImportNameIndex.ContainsKey(def.Name))
{
PrintLineError(protoDef, element,
"import `{0}` duplicated", def.Name);
return(false);
}
protoDef.Imports.Add(def);
protoDef.ImportNameIndex.Add(def.Name, def);
return(true);
}
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 AddEnumMapDef(
ProtocolDescriptor.ProtocolDef protoDef, XElement element)
{
// check name attr
string name;
{
XAttribute attr = element.Attribute("name");
if (attr == null)
{
PrintLineError(protoDef, element,
"`enum_map` node must contain a `name` attribute");
return(false);
}
name = attr.Value;
}
if (Regex.IsMatch(name, @"^[a-zA-Z_]\w*$") == false)
{
PrintLineError(protoDef, element,
"`enum_map` node `name` attribute is invalid");
return(false);
}
if (protoDef.EnumMapNameIndex.ContainsKey(name) ||
protoDef.EnumNameIndex.ContainsKey(name) ||
protoDef.StructNameIndex.ContainsKey(name))
{
PrintLineError(protoDef, element,
"`enum_map` node `name` attribute duplicated");
return(false);
}
ProtocolDescriptor.EnumMapDef def =
new ProtocolDescriptor.EnumMapDef();
def.ParentRef = protoDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
// parse items
{
IEnumerator <XElement> iter =
element.Elements().GetEnumerator();
while (iter.MoveNext())
{
XElement childElement = iter.Current;
if (childElement.Name != "item")
{
PrintLineError(protoDef, childElement,
"expect a `item` node");
return(false);
}
if (AddEnumMapItemDef(protoDef, def,
childElement) == false)
{
return(false);
}
}
}
protoDef.EnumMaps.Add(def);
protoDef.EnumMapNameIndex.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 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 AddEnumItemDef(
ProtocolDescriptor.ProtocolDef protoDef,
ProtocolDescriptor.EnumDef enumDef, 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 (enumDef.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;
}
}
ProtocolDescriptor.EnumDef.ItemDef def =
new ProtocolDescriptor.EnumDef.ItemDef();
def.ParentRef = enumDef;
def.Name = name;
def.LineNumber = GetLineNumber(element);
if (val == "")
{
// default
def.Type = ProtocolDescriptor.EnumDef.ItemType.Default;
if (enumDef.Items.Count == 0)
{
def.IntValue = 0;
}
else
{
def.IntValue =
enumDef.Items[enumDef.Items.Count - 1].IntValue + 1;
}
}
else if (Regex.IsMatch(val, @"^(-)?[0-9]+$"))
{
// int
def.Type = ProtocolDescriptor.EnumDef.ItemType.Int;
def.IntValue = int.TryParse(val, out def.IntValue)
? def.IntValue : 0;
}
else
{
string[] parts = val.Split('.');
if (parts.Length == 1)
{
// current enum
string refDefName = parts[0];
ProtocolDescriptor.EnumDef.ItemDef refDef = null;
if (enumDef.ItemNameIndex.TryGetValue(
refDefName, out refDef) == false)
{
PrintLineError(protoDef, element,
"enum item `{0}` is undefined", refDefName);
return(false);
}
def.Type =
ProtocolDescriptor.EnumDef.ItemType.CurrentEnumRef;
def.IntValue = refDef.IntValue;
def.RefEnumItemDef = refDef;
}
else if (parts.Length == 2)
{
// other enum in same file
string refEnumDefName = parts[0];
string refDefName = parts[1];
ProtocolDescriptor.EnumDef refEnumDef = null;
if (protoDef.EnumNameIndex.TryGetValue(
refEnumDefName, out refEnumDef) == false)
{
PrintLineError(protoDef, element,
"enum `{0}` is undefined", refEnumDefName);
return(false);
}
ProtocolDescriptor.EnumDef.ItemDef refDef = null;
if (refEnumDef.ItemNameIndex.TryGetValue(
refDefName, out refDef) == false)
{
PrintLineError(protoDef, element,
"enum item `{0}` is undefined", refDefName);
return(false);
}
def.Type =
ProtocolDescriptor.EnumDef.ItemType.OtherEnumRef;
def.IntValue = refDef.IntValue;
def.RefEnumItemDef = refDef;
}
else if (parts.Length == 3)
{
// other enum in other file
string refProtoDefName = parts[0];
string refEnumDefName = parts[1];
string refDefName = parts[2];
ProtocolDescriptor.ProtocolDef refProtoDef = null;
if (this.descriptor.ImportedProtos.TryGetValue(
refProtoDefName, out refProtoDef) == false)
{
PrintLineError(protoDef, element,
"protocol `{0}` is undefined", refProtoDefName);
return(false);
}
ProtocolDescriptor.EnumDef refEnumDef = null;
if (refProtoDef.EnumNameIndex.TryGetValue(
refEnumDefName, out refEnumDef) == false)
{
PrintLineError(protoDef, element,
"enum `{0}` is undefined", refEnumDefName);
return(false);
}
ProtocolDescriptor.EnumDef.ItemDef refDef = null;
if (refEnumDef.ItemNameIndex.TryGetValue(
refDefName, out refDef) == false)
{
PrintLineError(protoDef, element,
"enum item `{0}` is undefined", refDefName);
return(false);
}
def.Type =
ProtocolDescriptor.EnumDef.ItemType.OtherEnumRef;
def.IntValue = refDef.IntValue;
def.RefEnumItemDef = refDef;
}
else
{
PrintLineError(protoDef, element,
"enum value `{0}` is invalid", val);
return(false);
}
}
enumDef.Items.Add(def);
enumDef.ItemNameIndex.Add(def.Name, def);
return(true);
}
private ProtocolDescriptor.ProtocolDef ParseProtocol(
string protoFilePath, List <string> protoSearchPath)
{
ProtocolDescriptor.ProtocolDef protoDef = null;
// check is already imported
string protoName = Path.GetFileNameWithoutExtension(protoFilePath);
if (this.descriptor.ImportedProtos.TryGetValue(
protoName, out protoDef))
{
return(protoDef);
}
// get file full path
string protoFileFullPath = GetProtoFileFullPath(
protoFilePath, protoSearchPath);
if (protoFileFullPath == "")
{
Console.Error.WriteLine(string.Format(
"error: can not find protocol file `{0}`", protoFilePath));
return(null);
}
// load xml doc
XDocument xmlDoc = LoadProtoFile(protoFileFullPath);
if (xmlDoc == null)
{
return(null);
}
protoDef = new ProtocolDescriptor.ProtocolDef();
protoDef.Name = protoName;
protoDef.FilePath = protoFileFullPath;
// add to imported cache first to prevent circular import
this.descriptor.ImportedProtos.Add(protoName, protoDef);
// check root node name
if (xmlDoc.Root.Name != "protocol")
{
PrintLineError(protoDef, xmlDoc.Root,
"root node must be `protocol` node");
return(null);
}
// parse imports
{
IEnumerator <XElement> iter = xmlDoc.XPathSelectElements(
"/protocol/import").GetEnumerator();
while (iter.MoveNext())
{
XElement element = iter.Current;
// check import self
string refProtoName =
Path.GetFileNameWithoutExtension(element.Value);
if (refProtoName == protoDef.Name)
{
PrintLineError(protoDef, element,
"can not import self");
return(null);
}
ProtocolDescriptor.ProtocolDef externalProtoDef =
ParseProtocol(element.Value, protoSearchPath);
if (externalProtoDef == null)
{
PrintLineError(protoDef, element,
"load external file `{0}` failed",
element.Value);
return(null);
}
if (AddImportDef(protoDef, element,
externalProtoDef) == false)
{
return(null);
}
}
}
// parse namespaces
{
IEnumerator <XElement> iter = xmlDoc.XPathSelectElements(
"/protocol/namespace").GetEnumerator();
while (iter.MoveNext())
{
XElement element = iter.Current;
if (AddNamespaceDef(protoDef, element) == false)
{
return(null);
}
}
}
// parse enums
{
IEnumerator <XElement> iter = xmlDoc.XPathSelectElements(
"/protocol/enum").GetEnumerator();
while (iter.MoveNext())
{
XElement element = iter.Current;
if (AddEnumDef(protoDef, element) == false)
{
return(null);
}
}
}
// parse structs
{
IEnumerator <XElement> iter = xmlDoc.XPathSelectElements(
"/protocol/struct").GetEnumerator();
while (iter.MoveNext())
{
XElement element = iter.Current;
if (AddStructDef(protoDef, element) == false)
{
return(null);
}
}
}
// parse enum maps
{
IEnumerator <XElement> iter = xmlDoc.XPathSelectElements(
"/protocol/enum_map").GetEnumerator();
while (iter.MoveNext())
{
XElement element = iter.Current;
if (AddEnumMapDef(protoDef, element) == false)
{
return(null);
}
}
}
ProcessImportedProtocols(protoDef);
return(protoDef);
}
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;
}
}
}