← Back to branch summary

~alexreg/mathtexdotnet/0.1

« back to all changes in this revision

Viewing changes to TexDotNet/Semantics/TexParser.cs

  • Committer: Alex Regueiro
  • Date: 2009-09-19 13:17:06 UTC
  • Revision ID: alexreg@gmail.com-20090919131706-m1j55tqrp3m4avck
Updated grammar specification.
Fixed handling of signed values in parser. Parser now correctly handles implicit multiplication (signed value followed by one or more values).

Show diffs side-by-side

added added

removed removed

Lines of Context:
TexDotNet/Semantics/TexParser.cs
36
36
                    node.Children.Add(new ParseNode(tokenStream.Current));
37
37
                    tokenStream.ForceMoveNext();
38
38
                    break;
39
 
                case SymbolKind.Letter:
40
 
                case SymbolKind.GreekLetter:
41
 
                    // Implicitly multiply adjacent letter tokens.
42
 
                    node.Children.Add(new ParseNode(Token.FromKind(SymbolKind.Dot)));
43
 
                    break;
44
39
                default:
45
40
                    return node;
46
41
            }
51
46
        private ParseNode ParseTerm(TokenStream tokenStream)
52
47
        {
53
48
            var node = new ParseNode(ParseNodeKind.InfixOperator);
54
 
            node.Children.Add(ParseSignedValueOptional(tokenStream));
 
49
            node.Children.Add(ParseImplicitTermOptional(tokenStream));
55
50
            switch (tokenStream.Current.Symbol)
56
51
            {
57
52
                case SymbolKind.Cross:
66
61
            return node;
67
62
        }
68
63
 
 
64
        private ParseNode ParseImplicitTermOptional(TokenStream tokenStream)
 
65
        {
 
66
            var node = new ParseNode(ParseNodeKind.PostfixOperator);
 
67
            node.Children.Add(ParseSignedValue(tokenStream));
 
68
            ParseNode valueNode;
 
69
            while ((valueNode = ParseValueOptional(tokenStream)) != null)
 
70
                node.Children.Add(valueNode);
 
71
            node.Children.Add(new ParseNode(Token.FromKind(SymbolKind.Dot)));
 
72
            return node;
 
73
        }
 
74
 
 
75
        private ParseNode ParseSignedValue(TokenStream tokenStream)
 
76
        {
 
77
            var node = ParseSignedValueOptional(tokenStream);
 
78
            if (node == null)
 
79
                throw new ParserException(tokenStream.Current,
 
80
                    "Expected a value.");
 
81
            return node;
 
82
        }
 
83
 
69
84
        private ParseNode ParseSignedValueOptional(TokenStream tokenStream)
70
85
        {
71
86
            var node = new ParseNode(ParseNodeKind.PrefixOperator);
73
88
            {
74
89
                case SymbolKind.Plus:
75
90
                case SymbolKind.Minus:
76
 
                    var signNode = new ParseNode(tokenStream.Current);
 
91
                    node.Children.Add(new ParseNode(tokenStream.Current));
77
92
                    tokenStream.ForceMoveNext();
78
93
                    break;
79
94
            }
131
146
 
132
147
        private ParseNode ParseValue(TokenStream tokenStream)
133
148
        {
 
149
            var node = ParseValueOptional(tokenStream);
 
150
            if (node == null)
 
151
                throw new ParserException(tokenStream.Current,
 
152
                    "Expected one of the following: number, letter, open bracket, fraction, binomial, root, function.");
 
153
            return node;
 
154
        }
 
155
 
 
156
        private ParseNode ParseValueOptional(TokenStream tokenStream)
 
157
        {
134
158
            ParseNode node;
135
159
            node = ParseRawValueOptional(tokenStream);
136
160
            if (node == null)
147
171
                node = ParseFunctionOptional(tokenStream);
148
172
            if (node == null)
149
173
                node = ParseTextOptional(tokenStream);
150
 
            if (node == null)
151
 
                throw new ParserException(tokenStream.Current,
152
 
                    "Expected one of the following: number, letter, open bracket, fraction, binomial, root " +
153
 
                    "function.");
154
174
            return node;
155
175
        }
156
176
 
339
359
        private ParseNode ParseTextOptional(TokenStream tokenStream)
340
360
        {
341
361
            if (tokenStream.Current.Symbol != SymbolKind.Text)
342
 
                throw new ParserException(tokenStream.Current, new[] {
343
 
                    SymbolKind.Text });
 
362
                return null;
344
363
            tokenStream.ForceMoveNext();
345
364
            switch (tokenStream.Current.Symbol)
346
365
            {
352
371
                        sb.Append((char)tokenStream.Current.Value);
353
372
                        tokenStream.ForceMoveNext();
354
373
                    }
 
374
                    if (sb.Length == 0)
 
375
                        throw new ParserException(tokenStream.Current,
 
376
                            "A text value must contain at least one character.");
355
377
                    tokenStream.ForceMoveNext();
356
378
                    return new ParseNode(Token.FromValue(SymbolKind.Text, sb.ToString()));
357
379
                default:
358
 
                    return null;
 
380
                    throw new ParserException(tokenStream.Current, new[] {
 
381
                        SymbolKind.GroupOpen});
359
382
            }
360
383
        }
361
384
    }