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