Esempio n. 1
0
 public Chunk ParseChunk(ParserInput<char> input, out bool success)
 {
     this.SetInput(input);
     Chunk chunk = ParseChunk(out success);
     if (this.Position < input.Length)
     {
         success = false;
         Error("Failed to parse remaining input.");
     }
     return chunk;
 }
 public YamlStream ParseYamlStream(ParserInput<char> input, out bool success)
 {
     this.SetInput(input);
     YamlStream yamlStream = ParseYamlStream(out success);
     if (this.Position < input.Length)
     {
         success = false;
         Error("Failed to parse remained input.");
     }
     return yamlStream;
 }
Esempio n. 3
0
        public void SetsNameCorrectly(string input, string name)
        {
            // Arrange
            var document   = new DocumentBuilder().Build();
            var structNode = ParserInput
                             .FromString(input)
                             .ParseInput(parser => parser.enumDefinition());

            // Act
            var symbol = this.Binder.Bind <Enum>(structNode, document);

            // Assert
            Assert.Equal(name, symbol.Name);
        }
Esempio n. 4
0
        public void IndicatesWhenValueIsImplicit(string input, bool isImplicit)
        {
            // Arrange
            var @enum      = new EnumBuilder().Build();
            var memberNode = ParserInput
                             .FromString(input)
                             .ParseInput(parser => parser.enumMember());

            // Act
            var member = this.Binder.Bind <EnumMember>(memberNode, @enum);

            // Assert
            Assert.Equal(isImplicit, member.IsValueImplicit);
        }
Esempio n. 5
0
        protected override (IParseTree elementNode, ICollectionType collectionType) ParseInput(string input)
        {
            var node = ParserInput
                       .FromString(input)
                       .ParseInput(parser => parser.setType());

            var setType = new SetTypeBuilder()
                          .SetNode(node)
                          .SetParent(this.Field)
                          .SetBinderProvider(this.BinderProvider)
                          .Build();

            return(node.fieldType(), setType);
        }
Esempio n. 6
0
        public void Bind_StructNameNotSupplied_Null()
        {
            // Arrange
            var document      = new DocumentBuilder().Build();
            var structContext = ParserInput
                                .FromString("union {}")
                                .ParseInput(parser => parser.unionDefinition());

            // Act
            var union = this.binder.Bind <IUnion>(structContext, document);

            // Assert
            Assert.Null(union.Name);
        }
Esempio n. 7
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);
        }
Esempio n. 8
0
        public void SetsInvalidValueReasonCorrectly(string input, InvalidEnumValueReason expected)
        {
            // Arrange
            var @enum      = new EnumBuilder().Build();
            var memberNode = ParserInput
                             .FromString(input)
                             .ParseInput(parser => parser.enumMember());

            // Act
            var member = this.Binder.Bind <EnumMember>(memberNode, @enum);

            // Assert
            Assert.Equal(expected, member.InvalidValueReason);
        }
Esempio n. 9
0
        public void SetsNameCorrectly(string input, string expectedResult)
        {
            // Arrange
            var @enum      = new EnumBuilder().Build();
            var memberNode = ParserInput
                             .FromString(input)
                             .ParseInput(parser => parser.enumMember());

            // Act
            var member = this.Binder.Bind <EnumMember>(memberNode, @enum);

            // Assert
            Assert.Equal(expectedResult, member.Name);
        }
Esempio n. 10
0
        public void Push(TextReader stream, string filename, int lineNumber = 1, TextWriter sourceWriter = null)
        {
            var pi = new ParserInput
            {
                FileName          = filename,
                Reader            = stream,
                LineNumberCounter = lineNumber,
                Writer            = sourceWriter
            };

            m_ParserInputs.Add(pi);
            cur_linenumber = pi.LineNumberCounter;
            cur_filename   = pi.FileName;
        }
Esempio n. 11
0
        public void Bind_FieldIdSupplied_SetsRawFieldId()
        {
            // Arrange
            var @struct      = new StructBuilder().Build();
            var fieldContext = ParserInput
                               .FromString("4: i32 Id")
                               .ParseInput(parser => parser.field());

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

            // Assert
            Assert.Equal("4", field.RawFieldId);
        }
Esempio n. 12
0
        public void NameSupplied_SetsName()
        {
            // Arrange
            var input = ParserInput
                        .FromString("const i32 MaxPageSize = 100")
                        .ParseInput(parser => parser.constDefinition());
            var parent = Substitute.For <IDocument>();

            // Act
            var result = this.constantBinder.Bind <IConstant>(input, parent);

            // Assert
            Assert.Equal("MaxPageSize", result.Name);
        }
Esempio n. 13
0
        public void Bind_ExceptionNameNotSupplied_Null()
        {
            // Arrange
            var document      = new DocumentBuilder().Build();
            var exceptionNode = ParserInput
                                .FromString("exception {}")
                                .ParseInput(parser => parser.exceptionDefinition());

            // Act
            var exception = this.binder.Bind <IException>(exceptionNode, document);

            // Assert
            Assert.Null(exception.Name);
        }
Esempio n. 14
0
        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);
        }
Esempio n. 15
0
        public void NameNotSupplied_Null()
        {
            // Arrange
            var input = ParserInput
                        .FromString("const i32 = 100")
                        .ParseInput(parser => parser.constDefinition());
            var parent = Substitute.For <IDocument>();

            // Act
            var result = this.constantBinder.Bind <IConstant>(input, parent);

            // Assert
            Assert.Null(result.Name);
        }
Esempio n. 16
0
        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);
        }
Esempio n. 17
0
        public void BasicTest()
        {
            var parser = new StringTokenParser();

            using (var input = ParserInput.CreateFromString("\"Hello World!\""))
                Assert.Equal("Hello World!", parser.Parse(input));

            using (var input = ParserInput.CreateFromString("\"\\\\\""))
                Assert.Equal("\\", parser.Parse(input));

            parser.EscapedCharLookup.Add('t', '\t');

            using (var input = ParserInput.CreateFromString("\"\\tHello\""))
                Assert.Equal("\tHello", parser.Parse(input));
        }
Esempio n. 18
0
        public void CanResolveAllBaseTypes(string baseType, string requiredType, string optionalType)
        {
            // Arrange
            var node = ParserInput
                       .FromString(baseType)
                       .ParseInput(parser => parser.baseType());
            var parent = Substitute.For <IField>();

            // Act
            var type = BaseType.Resolve(node, parent);

            // Assert
            Assert.Equal(baseType, type.Name);
            Assert.Equal(requiredType, type.CSharpRequiredTypeName);
            Assert.Equal(optionalType, type.CSharpOptionalTypeName);
        }
Esempio n. 19
0
        public void NamespaceProvided_SetsNamespace()
        {
            // Arrange
            var document           = new DocumentBuilder().Build();
            var binderProvider     = Substitute.For <IBinderProvider>();
            var binder             = new NamespaceBinder(binderProvider);
            var namespaceStatement = ParserInput
                                     .FromString("namespace * Thrift.Net.Examples")
                                     .ParseInput(parser => parser.namespaceStatement());

            // Act
            var @namespace = binder.Bind <Namespace>(namespaceStatement, document);

            // Assert
            Assert.Equal("Thrift.Net.Examples", @namespace.NamespaceName);
        }
Esempio n. 20
0
        public void KeyAndValuesProvided_IncludesBothInType()
        {
            // Arrange
            var node = ParserInput
                       .FromString("map<string, bool>")
                       .ParseInput(parser => parser.mapType());

            var mapType = new MapTypeBuilder()
                          .SetNode(node)
                          .SetParent(this.field)
                          .SetBinderProvider(this.binderProvider)
                          .Build();

            var binder = Substitute.For <IBinder>();

            this.binderProvider.GetBinder(default).ReturnsForAnyArgs(binder);
Esempio n. 21
0
        public void ScopeNotProvided_Null()
        {
            // Arrange
            var document           = new DocumentBuilder().Build();
            var binderProvider     = Substitute.For <IBinderProvider>();
            var binder             = new NamespaceBinder(binderProvider);
            var namespaceStatement = ParserInput
                                     .FromString("namespace Thrift.Net.Examples")
                                     .ParseInput(parser => parser.namespaceStatement());

            // Act
            var @namespace = binder.Bind <Namespace>(namespaceStatement, document);

            // Assert
            Assert.Null(@namespace.Scope);
        }
Esempio n. 22
0
        public void BasicLookupTest()
        {
            const string source = "abcdef 12345";

            using (var input = ParserInput.CreateFromString(source))
            {
                Assert.Equal(0, input.LookaheadCount);
                Assert.Equal(0, input.Offset);

                var pos1 = TextPosition.Start;

                // lookahead 1
                Assert.Equal(pos1, input.TextPosition);
                Assert.True(input.TryPeekChar(out var ch));
                Assert.Equal('a', ch);
                Assert.Equal(pos1, input.TextPosition);
                Assert.Equal(1, input.LookaheadCount);
                Assert.Equal(0, input.Offset);

                // lookahead 2
                Assert.True(input.TryPeekChar(out ch));
                Assert.Equal('b', ch);
                Assert.Equal(pos1, input.TextPosition);
                Assert.Equal(2, input.LookaheadCount);
                Assert.Equal(0, input.Offset);

                input.ClearLookahead();
                Assert.Equal(0, input.LookaheadCount);
                Assert.Equal(pos1, input.TextPosition);

                // lookahead 1
                Assert.Equal(pos1, input.TextPosition);
                Assert.True(input.TryPeekChar(out ch));
                Assert.Equal('a', ch);
                Assert.Equal(pos1, input.TextPosition);
                Assert.Equal(1, input.LookaheadCount);
                Assert.Equal(0, input.Offset);

                // lookahead 2
                Assert.True(input.TryPeekChar(out ch));
                Assert.Equal('b', ch);
                Assert.Equal(pos1, input.TextPosition);
                Assert.Equal(2, input.LookaheadCount);
                Assert.Equal(0, input.Offset);
            }
        }
Esempio n. 23
0
        public void NodeIsOnlyMember_ReturnsZero()
        {
            // Arrange
            var input =
                @"enum UserType {
    User
}";
            var enumNode = ParserInput
                           .FromString(input)
                           .ParseInput(parser => parser.enumDefinition());

            // Act
            var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[0], this.parent);

            // Assert
            Assert.Equal(0, member.Value);
        }
Esempio n. 24
0
        protected void AssertCompilerDoesNotReturnMessage(
            string input,
            CompilerMessageId messageId)
        {
            // Arrange
            var compiler    = new ThriftCompiler();
            var parserInput = ParserInput.FromString(input);

            // Act
            var result = compiler.Compile(parserInput.GetStream());

            // Assert
            var message = result.Messages.FirstOrDefault(m => m.MessageId == messageId);

            Assert.True(
                message == null,
                $"Message Id '{messageId}' should not have been reported");
        }
Esempio n. 25
0
        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);
        }
Esempio n. 26
0
        public void PreviousSiblingHasCustomValue_ReturnsNextValue()
        {
            // Arrange
            var input =
                @"enum UserType {
    User = 5,
    Administrator
}";
            var enumNode = ParserInput
                           .FromString(input)
                           .ParseInput(parser => parser.enumDefinition());

            // Act
            var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[1], this.parent);

            // Assert
            Assert.Equal(6, member.Value);
        }
Esempio n. 27
0
        public void Bind_UserType_ResolvesType()
        {
            // Arrange
            var field = new FieldBuilder().Build();
            var node  = ParserInput
                        .FromString("User")
                        .ParseInput(parser => parser.fieldType());

            this.binderProvider.GetBinder(node.userType()).Returns(this.typeBinder);
            var userType = Substitute.For <IUserType>();

            this.typeBinder.Bind <IFieldType>(node.userType(), field).Returns(userType);

            // Act
            var type = this.binder.Bind <IFieldType>(node, field);

            // Assert
            Assert.Same(userType, type);
        }
        public void TypeCanBeResolvedFromParent_ResolvesType()
        {
            // Arrange
            var binder       = new UserTypeBinder();
            var resolvedType = Substitute.For <INamedTypeSymbol>();
            var field        = Substitute.For <IField>();

            field.ResolveType("UserType").Returns(resolvedType);

            var node = ParserInput
                       .FromString("UserType")
                       .ParseInput(parser => parser.userType());

            // Act
            var result = binder.Bind <UserType>(node, field);

            // Assert
            Assert.Same(resolvedType, result.Definition);
        }
        public void TestParser() {
            System.Console.WriteLine(Directory.GetCurrentDirectory());

            var files = Directory
                .GetFiles("../../TestPrograms")
                .Where(_ => _.EndsWith(".c"));

            var sources = files.Select(File.ReadAllText).ToArray();

            foreach (var source in sources) {
                var scanner = new Scanner(source);
                var tokens = scanner.Tokens;
                var env = new ParserEnvironment();
                var input = new ParserInput(env, scanner.Tokens);
                var result = CParsers.TranslationUnit.Parse(input);
                Assert.IsTrue(result.IsSuccessful);
                Assert.IsTrue(result.Source.Count() == 1);
            }
        }
Esempio n. 30
0
        public void TestCompiler() {
            Console.WriteLine(Directory.GetCurrentDirectory());

            var files = Directory
                .GetFiles("../../TestPrograms")
                .Where(_ => _.EndsWith(".c"));

            var sources = files.Select(File.ReadAllText).ToArray();

            foreach (var source in sources) {
                var scanner = new Scanner(source);
                var tokens = scanner.Tokens;
                var env = new ParserEnvironment();
                var input = new ParserInput(env, tokens);
                var parserResult = CParsers.TranslationUnit.Parse(input);
                var semantResult = parserResult.Result.GetTranslnUnit();
                semantResult.Value.CodeGenerate(new CGenState());
            }
        }
Esempio n. 31
0
        public void ValueNotProvided_DoesNotIncludeInName()
        {
            // Arrange
            var node = ParserInput
                       .FromString("map<string,>")
                       .ParseInput(parser => parser.mapType());

            var mapType = new MapTypeBuilder()
                          .SetNode(node)
                          .SetParent(this.field)
                          .SetBinderProvider(this.binderProvider)
                          .Build();

            // Act
            var name = mapType.Name;

            // Assert
            Assert.Equal("map<string,>", name);
        }
Esempio n. 32
0
        public void PreviousSiblingValueIsInvalid_IgnoresPreviousSibling()
        {
            // Arrange
            var input =
                @"enum UserType {
    User = 2,
    Administrator = -1,
    Guest
}";
            var enumNode = ParserInput
                           .FromString(input)
                           .ParseInput(parser => parser.enumDefinition());

            // Act
            var member = this.Binder.Bind <EnumMember>(enumNode.enumMember()[2], this.parent);

            // Assert
            Assert.Equal(3, member.Value);
        }
Esempio n. 33
0
        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);
        }
Esempio n. 34
0
        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);
        }
Esempio n. 35
0
		public YamlStream ParseYamlStream(ParserInput<Char> input, out bool success)
		{
			this.SetInput(input);
			YamlStream yamlStream = ParseYamlStream(out success);
			return yamlStream;
		}
Esempio n. 36
0
 private void SetInput(ParserInput<char> input)
 {
     Input = input;
     position = 0;
     ParsingResults.Clear();
 }
 private void SetInput(ParserInput<char> input)
 {
     Input = input;
     position = 0;
 }