public void Begin(MagicNumber tagClass, int classStringId, TagLayoutGuess layout)
        {
            if (_writer != null)
                throw new InvalidOperationException("Cannot begin a new tag while another is still in progress");

            // Convert the class name to a pascal case string and use that as the file name
            var name = _stringIds.GetString(classStringId);
            if (string.IsNullOrEmpty(name))
                throw new InvalidOperationException("Unable to look up the tag class name");
            name = ConvertToPascalCase(name);
            var path = Path.Combine(_outDir, name + ".hpp");
            _writer = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write));

            // Write the C++ header
            _writer.WriteLine("#pragma once");
            _writer.WriteLine("#include \"Tags.hpp\"");
            _writer.WriteLine();
            _writer.WriteLine("namespace Blam");
            _writer.WriteLine("{");
            _writer.WriteLine("\tnamespace Tags");
            _writer.WriteLine("\t{");

            _builder = new StructBuilder(_writer, 2, name);
            _builder.Begin(tagClass, classStringId, layout);
        }
Exemple #2
0
        /// <summary>
        /// 创建一个结构体
        /// </summary>
        /// <returns></returns>
        public virtual StructBuilder CreateStruct()
        {
            var member = new StructBuilder();

            _namespace.Structs.Add(member);
            return(member);
        }
Exemple #3
0
        public void Bind_FieldTypeSupplied_UsesBinderToResolveType()
        {
            // Arrange
            var @struct = new StructBuilder().Build();
            var input   =
                @"struct User {
    i32 Id
}";
            var structNode = ParserInput
                             .FromString(input)
                             .ParseInput(parser => parser.structDefinition());

            this.binderProvider.GetBinder(structNode.field()[0].fieldType())
            .Returns(this.typeBinder);
            var type = Substitute.For <IFieldType>();

            this.typeBinder.Bind <IFieldType>(
                structNode.field()[0].fieldType(), Arg.Any <ISymbol>())
            .Returns(type);

            // Act
            var field = this.binder.Bind <Field>(structNode.field()[0], @struct);

            // Assert
            Assert.Same(type, field.Type);
        }
        public void Begin(MagicNumber tagClass, int classStringId, TagLayoutGuess layout)
        {
            if (_writer != null)
            {
                throw new InvalidOperationException("Cannot begin a new tag while another is still in progress");
            }

            // Convert the class name to a pascal case string and use that as the file name
            var name = _stringIds.GetString(classStringId);

            if (string.IsNullOrEmpty(name))
            {
                throw new InvalidOperationException("Unable to look up the tag class name");
            }
            name = ConvertToPascalCase(name);
            var path = Path.Combine(_outDir, name + ".hpp");

            _writer = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write));

            // Write the C++ header
            _writer.WriteLine("#pragma once");
            _writer.WriteLine("#include \"Tags.hpp\"");
            _writer.WriteLine();
            _writer.WriteLine("namespace Blam");
            _writer.WriteLine("{");
            _writer.WriteLine("\tnamespace Tags");
            _writer.WriteLine("\t{");

            _builder = new StructBuilder(_writer, 2, name);
            _builder.Begin(tagClass, classStringId, layout);
        }
        /// <inheritdoc />
        protected override Struct Bind(StructDefinitionContext node, IDocument parent)
        {
            var builder = new StructBuilder()
                          .SetNode(node)
                          .SetParent(parent)
                          .SetBinderProvider(this.binderProvider)
                          .SetName(node.name?.Text);

            return(builder.Build());
        }
Exemple #6
0
        protected Struct SetupMember(StructDefinitionContext structNode, string structName, Document document)
        {
            var member = new StructBuilder()
                         .SetNode(structNode)
                         .SetName(structName)
                         .Build();

            this.BinderProvider.GetBinder(structNode).Returns(this.structBinder);
            this.StructBinder.Bind <INamedSymbol>(structNode, document).Returns(member);
            this.StructBinder.Bind <Struct>(structNode, document).Returns(member);

            return(member);
        }
    public static void Do2()
    {
        Debug.Log("读取所有Json数据");
        var json_list = JsonDataManager.ReadTableList();

        Debug.Log("正在创建Struct");
        StructBuilder.CreateDataStruct(json_list);

        Debug.Log("正在创建ConfigReader");
        ReaderBuilder.CreateConfigReader(json_list);

        Debug.Log("创建完毕");
    }
Exemple #8
0
        public void 只命名()
        {
            StructBuilder builder = CodeSyntax.CreateStruct("Test");


            var result = builder.ToFormatCode();

#if Log
            _tempOutput.WriteLine(result.WithUnixEOL());
#endif
            Assert.Equal(@"struct Test
{
}", result.WithUnixEOL());
        }
Exemple #9
0
        internal BinaryStruct AppendPreCompile(StructBuilder builder)
        {
            if (!TypeCacheMap.ContainsKey(builder.CurrentType))
            {
                TypeCacheMap.TryAdd(builder.CurrentType, new ConcurrentDictionary <string, BinaryStruct>());
            }
            else
            {
                TypeCacheMap[builder.CurrentType].Clear();
            }
            TypeCacheMap[builder.CurrentType].TryAdd("", builder.CurrentStruct);

            return(builder.CurrentStruct);
        }
        public void Bind_FieldRequirednessOptional_SetsRequiredness()
        {
            // Arrange
            var @struct      = new StructBuilder().Build();
            var fieldContext = ParserInput
                               .FromString("optional i32 Id")
                               .ParseInput(parser => parser.field());

            // Act
            var field = this.binder.Bind <Field>(fieldContext, @struct);

            // Assert
            Assert.Equal(FieldRequiredness.Optional, field.Requiredness);
        }
        public void Bind_FieldIdProvided_SetsFieldId()
        {
            // Arrange
            var @struct      = new StructBuilder().Build();
            var fieldContext = ParserInput
                               .FromString("1: i32 Id")
                               .ParseInput(parser => parser.field());

            // Act
            var field = this.binder.Bind <Field>(fieldContext, @struct);

            // Assert
            Assert.Equal(1, field.FieldId);
        }
        public void Bind_FieldIdNotAnInteger_SetsFieldIdNull()
        {
            // Arrange
            var @struct      = new StructBuilder().Build();
            var fieldContext = ParserInput
                               .FromString("abc: i32 Id")
                               .ParseInput(parser => parser.field());

            // Act
            var field = this.binder.Bind <Field>(fieldContext, @struct);

            // Assert
            Assert.Null(field.FieldId);
        }
Exemple #13
0
        public void Bind_IdentifierSupplied_SetsIdentifier()
        {
            // Arrange
            var @struct      = new StructBuilder().Build();
            var fieldContext = ParserInput
                               .FromString("string Name")
                               .ParseInput(parser => parser.field());

            // Act
            var field = this.binder.Bind <Field>(fieldContext, @struct);

            // Assert
            Assert.Equal("Name", field.Name);
        }
            void ITagElementGuessVisitor.Visit(uint offset, TagBlockGuess guess)
            {
                var structName = string.Format("TagBlock{0}", _nextUnknownBlock++);

                _writer.WriteLine("{0}struct {1};", _indent, structName);
                using (var blockWriter = new StringWriter())
                {
                    var blockBuilder = new StructBuilder(blockWriter, _indentLevel, structName);
                    blockBuilder._nextUnknownBlock = _nextUnknownBlock;
                    LayoutGuessWriter.Write(null, guess.ElementLayout, blockBuilder);
                    _subBlocks.Enqueue(blockWriter.ToString());
                    _nextUnknownBlock = blockBuilder._nextUnknownBlock;
                }
                AddUnknown(offset, string.Format("TagBlock<{0}>", structName));
            }
        public void Bind_FieldRequirednessNotSupplied_UsesDefault()
        {
            // Arrange
            var @struct = new StructBuilder().Build();

            var fieldContext = ParserInput
                               .FromString("i32 Id")
                               .ParseInput(parser => parser.field());

            // Act
            var field = this.binder.Bind <Field>(fieldContext, @struct);

            // Assert
            Assert.Equal(FieldRequiredness.Default, field.Requiredness);
        }
        public void Bind_FieldIdNotProvided_IndicatesFieldIdIsImplicit()
        {
            // Arrange
            var input =
                @"struct User {
    i32 Id
}";
            var @struct          = new StructBuilder().Build();
            var structDefinition = ParserInput
                                   .FromString(input)
                                   .ParseInput(parser => parser.structDefinition());

            // Act
            var field = this.binder.Bind <Field>(structDefinition.field()[0], @struct);

            // Assert
            Assert.True(field.IsFieldIdImplicit);
        }
        public void Bind_FieldIdNotProvided_SkipsExplicitFieldsWhenGeneratingIds()
        {
            // Arrange
            var input =
                @"struct User {
    i32 Id
    1: string Username
    string Email
}";
            var @struct          = new StructBuilder().Build();
            var structDefinition = ParserInput
                                   .FromString(input)
                                   .ParseInput(parser => parser.structDefinition());

            // Act
            var field = this.binder.Bind <Field>(structDefinition.field()[2], @struct);

            // Assert
            Assert.Equal(-2, field.FieldId);
        }
        public void Bind_FieldIdNotProvided_GeneratesNegativeIds()
        {
            // Arrange
            var input =
                @"struct User {
    i32 Id
    string Username
}";
            var @struct          = new StructBuilder().Build();
            var structDefinition = ParserInput
                                   .FromString(input)
                                   .ParseInput(parser => parser.structDefinition());

            // Act
            var idField       = this.binder.Bind <Field>(structDefinition.field()[0], @struct);
            var usernameField = this.binder.Bind <Field>(structDefinition.field()[1], @struct);

            // Assert
            Assert.Equal(-1, idField.FieldId);
            Assert.Equal(-2, usernameField.FieldId);
        }
Exemple #19
0
 /// <summary>
 /// 加入成员
 /// </summary>
 /// <param name="builder"></param>
 /// <returns></returns>
 public virtual TBuilder With(StructBuilder builder)
 {
     return(_TBuilder);
 }
Exemple #20
0
 public BuilderType AddInnerStruct(StructBuilder builder)
 {
     _members.Add(builder);
     return((BuilderType)this);
 }
Exemple #21
0
        public void 完整的测试()
        {
            StructBuilder builder = CodeSyntax.CreateStruct("Test")
                                    .WithAccess(NamespaceAccess.Public)
                                    .WithGeneric(b =>
            {
                b.WithCreate("T1").WithStruct()
                .WithCreate("T2").WithClass()
                .WithCreate("T3").WithNotnull()
                .WithCreate("T4").WithUnmanaged()
                .WithCreate("T5").WithNotnull()
                .WithCreate("T6").WithBase("Enum")
                .WithCreate("T7").WithBase("IEnumerable<int>")
                .WithCreate("T8").WithTo("T2")
                .WithCreate("T9").WithClass().WithNew()
                .WithCreate("T10").WithInterface("IEnumerator<int>", "IEnumerable<int>").WithNew();
            })
                                    .WithField("str", b =>
            {
                b.WithAccess(MemberAccess.Public)
                .WithKeyword(FieldKeyword.Readonly)
                .WithType("string");
            })
                                    .WithProperty("Get", b =>
            {
                b.WithAccess(MemberAccess.Public)
                .WithType("string")
                .WithGetSet("get { return str; }");
            })
                                    .WithMethod("Method", b =>
            {
                b.WithAccess(MemberAccess.Public)
                .WithReturnType("string")
                .WithBlock(@"return """";");
            });


            var result = builder.ToFormatCode();

#if Log
            _tempOutput.WriteLine(result.WithUnixEOL());
#endif
            Assert.Equal(@"public struct Test<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
    where T1 : struct where T2 : class where T3 : notnull where T4 : unmanaged where T5 : notnull where T6 : Enum where T7 : IEnumerable<int> where T8 : T2 where T9 : class, new()
    where T10 : IEnumerator<int>, IEnumerable<int>, new()
{
    public readonly string str;
    public string Get
    {
        get
        {
            return str;
        }
    }

    public string Method()
    {
        return """";
    }
}", result.WithUnixEOL());
        }
 void ITagElementGuessVisitor.Visit(uint offset, TagBlockGuess guess)
 {
     var structName = string.Format("TagBlock{0}", _nextUnknownBlock++);
     _writer.WriteLine("{0}struct {1};", _indent, structName);
     using (var blockWriter = new StringWriter())
     {
         var blockBuilder = new StructBuilder(blockWriter, _indentLevel, structName);
         blockBuilder._nextUnknownBlock = _nextUnknownBlock;
         LayoutGuessWriter.Write(null, guess.ElementLayout, blockBuilder);
         _subBlocks.Enqueue(blockWriter.ToString());
         _nextUnknownBlock = blockBuilder._nextUnknownBlock;
     }
     AddUnknown(offset, string.Format("TagBlock<{0}>", structName));
 }