Beispiel #1
0
        public override TableOrStructDefinition VisitType_decl([NotNull] FlatBuffersParser.Type_declContext context)
        {
            Dictionary <string, string> metadata = new MetadataVisitor().Visit(context.metadata());

            TableOrStructDefinition definition = new TableOrStructDefinition(
                context.IDENT().GetText(),
                this.parent);

            ErrorContext.Current.WithScope(definition.Name, () =>
            {
                definition.IsTable = context.GetChild(0).GetText() == "table";

                definition.NonVirtual = metadata.ParseNullableBooleanMetadata("nonVirtual");
                definition.ObsoleteDefaultConstructor = metadata.ParseBooleanMetadata("obsoleteDefaultConstructor");

                definition.RequestedSerializer = metadata.ParseMetadata <FlatBufferDeserializationOption?>(
                    "PrecompiledSerializer",
                    ParseSerailizerFlags,
                    FlatBufferDeserializationOption.Default,
                    null);

                if (!definition.IsTable && definition.RequestedSerializer != null)
                {
                    ErrorContext.Current.RegisterError("Structs may not have precompiled serializers.");
                }

                var fields = context.field_decl();
                if (fields != null)
                {
                    definition.Fields = fields.Select(x => new FieldVisitor().VisitField_decl(x)).ToList();
                }
            });

            return(definition);
        }
Beispiel #2
0
        public override TableOrStructDefinition VisitType_decl([NotNull] FlatBuffersParser.Type_declContext context)
        {
            Dictionary <string, string?> metadata = new MetadataVisitor().Visit(context.metadata());

            TableOrStructDefinition definition = new TableOrStructDefinition(
                context.IDENT().GetText(),
                this.parent);

            ErrorContext.Current.WithScope(definition.Name, () =>
            {
                definition.IsTable = context.GetChild(0).GetText() == "table";

                definition.NonVirtual = metadata.ParseNullableBooleanMetadata(MetadataKeys.NonVirtualProperty, MetadataKeys.NonVirtualPropertyLegacy);
                definition.ObsoleteDefaultConstructor = metadata.ParseBooleanMetadata(MetadataKeys.ObsoleteDefaultConstructor, MetadataKeys.ObsoleteDefaultConstructorLegacy);

                definition.RequestedSerializer = metadata.ParseMetadata <FlatBufferDeserializationOption?>(
                    new[] { MetadataKeys.SerializerKind, MetadataKeys.PrecompiledSerializerLegacy },
                    ParseSerailizerFlags,
                    FlatBufferDeserializationOption.Default,
                    null);

                if (!definition.IsTable && definition.RequestedSerializer != null)
                {
                    ErrorContext.Current.RegisterError("Structs may not have serializers.");
                }

                if (metadata.TryGetValue(MetadataKeys.FileIdentifier, out var fileId))
                {
                    if (!definition.IsTable)
                    {
                        ErrorContext.Current.RegisterError("Structs may not have file identifiers.");
                    }

                    definition.FileIdentifier = fileId;
                }

                var fields = context.field_decl();
                if (fields != null)
                {
                    foreach (var f in fields)
                    {
                        new FieldVisitor(definition).VisitField_decl(f);
                    }
                }
            });

            return(definition);
        }
Beispiel #3
0
        public override bool VisitField_decl([NotNull] FlatBuffersParser.Field_declContext context)
        {
            string name = context.IDENT().GetText();

            ErrorContext.Current.WithScope(name, () =>
            {
                Dictionary <string, string?> metadata = new MetadataVisitor().VisitMetadata(context.metadata());

                var(fieldType, vectorType, structVectorLength) = GetFbsFieldType(context, metadata);

                var definition = new FieldDefinition(this.parent, name, fieldType)
                {
                    VectorType = vectorType,
                };

                string?defaultValue = context.defaultValue_decl()?.GetText();
                if (defaultValue == "null")
                {
                    definition.IsOptionalScalar = true;
                }
                else if (!string.IsNullOrEmpty(defaultValue))
                {
                    definition.DefaultValue = defaultValue;
                }

                // standard metadata
                definition.Deprecated = metadata.ParseBooleanMetadata(MetadataKeys.Deprecated);
                definition.IsKey      = metadata.ParseBooleanMetadata(MetadataKeys.Key);

                // Flatsharp custom metadata
                definition.SortedVector = metadata.ParseBooleanMetadata(MetadataKeys.SortedVector, MetadataKeys.SortedVectorLegacy);
                definition.SharedString = metadata.ParseBooleanMetadata(MetadataKeys.SharedString, MetadataKeys.SharedStringLegacy);
                definition.NonVirtual   = metadata.ParseNullableBooleanMetadata(MetadataKeys.NonVirtualProperty, MetadataKeys.NonVirtualPropertyLegacy);
                definition.ForceWrite   = metadata.ParseNullableBooleanMetadata(MetadataKeys.ForceWrite);

                this.ParseIdMetadata(definition, metadata);

                definition.SetterKind = metadata.ParseMetadata(
                    new[] { MetadataKeys.Setter, MetadataKeys.SetterLegacy },
                    ParseSetterKind,
                    SetterKind.Public,
                    SetterKind.Public);

                if (structVectorLength == null)
                {
                    this.parent.Fields.Add(definition);
                }
                else if (this.parent.IsTable)
                {
                    ErrorContext.Current.RegisterError("Only structs may contain fixed-length vectors");
                }
                else
                {
                    List <string> groupNames = new List <string>();

                    for (int i = 0; i < structVectorLength.Value; ++i)
                    {
                        string name = $"__flatsharp__{definition.Name}_{i}";
                        this.parent.Fields.Add(definition with
                        {
                            Name           = name,
                            SetterKind     = SetterKind.Protected,
                            GetterModifier = AccessModifier.Protected,
                            CustomGetter   = $"{definition.Name}[{i}]"
                        });

                        groupNames.Add(name);
                    }
Beispiel #4
0
        public override FieldDefinition VisitField_decl([NotNull] FlatBuffersParser.Field_declContext context)
        {
            this.definition.Name = context.IDENT().GetText();

            ErrorContext.Current.WithScope(this.definition.Name, () =>
            {
                Dictionary <string, string> metadata = new MetadataVisitor().VisitMetadata(context.metadata());
                string fbsFieldType = context.type().GetText();

                this.definition.VectorType = VectorType.None;

                if (fbsFieldType.StartsWith("["))
                {
                    this.definition.VectorType = VectorType.IList;

                    // Trim the starting and ending square brackets.
                    fbsFieldType = fbsFieldType.Substring(1, fbsFieldType.Length - 2);

                    this.definition.VectorType = VectorType.IList;
                    if (metadata.TryGetValue("vectortype", out string vectorTypeString))
                    {
                        if (!Enum.TryParse <VectorType>(vectorTypeString, true, out var vectorType))
                        {
                            ErrorContext.Current?.RegisterError($"Unable to parse '{vectorTypeString}' as a vector type. Valid choices are: {string.Join(", ", Enum.GetNames(typeof(VectorType)))}.");
                        }

                        this.definition.VectorType = vectorType;
                    }
                }
                else if (metadata.ContainsKey("vectortype"))
                {
                    ErrorContext.Current?.RegisterError($"Non-vectors may not have the 'vectortype' attribute. Field = '{this.definition.Name}'");
                }

                this.definition.FbsFieldType = fbsFieldType;

                string defaultValue = context.defaultValue_decl()?.GetText();
                if (defaultValue == "null")
                {
                    this.definition.IsOptionalScalar = true;
                }
                else if (!string.IsNullOrEmpty(defaultValue))
                {
                    this.definition.DefaultValue = defaultValue;
                }

                this.definition.Deprecated   = metadata.ParseBooleanMetadata("deprecated");
                this.definition.IsKey        = metadata.ParseBooleanMetadata("key");
                this.definition.NonVirtual   = metadata.ParseNullableBooleanMetadata("nonVirtual");
                this.definition.SortedVector = metadata.ParseBooleanMetadata("sortedvector");
                this.definition.SharedString = metadata.ParseBooleanMetadata("sharedstring");

                this.definition.SetterKind = metadata.ParseMetadata(
                    "setter",
                    ParseSetterKind,
                    SetterKind.Public,
                    SetterKind.Public);

                // Attributes from FlatBuffers that we don't support.
                string[] unsupportedAttributes =
                {
                    "id", "required", "force_align", "bit_flags", "flexbuffer", "hash", "original_order"
                };

                foreach (var unsupportedAttribute in unsupportedAttributes)
                {
                    if (metadata.ContainsKey(unsupportedAttribute))
                    {
                        ErrorContext.Current?.RegisterError($"FlatSharpCompiler does not support the '{unsupportedAttribute}' attribute in FBS files.");
                    }
                }
            });

            return(this.definition);
        }