Esempio n. 1
0
        public static bool CanPrintAsNumber(UString textValue, Symbol typeMarker)
        {
            int la0;

            // Check if the typeMarker is potentially acceptable for printing as a number
            // line 26
            if (typeMarker.Name.TryGet(0, '\0') != '_' || !IsNormalIdentifier(typeMarker.Name))
            {
                return(false);
            }
            // line 28
            char firstTMChar = typeMarker.Name.TryGet(1, '\0');

            // line 29
            if (firstTMChar == 'e' || firstTMChar == 'E' || firstTMChar == 'p' || firstTMChar == 'P')
            {
                return(false);
            }

            // Prepare LexerSource needed by LLLPG, and our error counter
            // line 33
            if (src == null)
            {
                src           = new LexerSource <UString>(textValue, "", 0, false);
                src.ErrorSink = msgCounter = new NullMessageSink();
            }
            else
            {
                src.Reset(textValue, "", 0, false);                     // re-use old object
                msgCounter.ResetCountersToZero();
            }

            // Find out whether textValue is in numeric format
            // line 42
            bool isHex = false;

            // Line 44: ([−])?
            do
            {
                la0 = src.LA0;
                if (la0 == '−')
                {
                    src.Skip();
                }
                else if (la0 == -1 || la0 == '.' || la0 >= '0' && la0 <= '9')
                {
                    ;
                }
                else
                {
                    src.Error(0, "In rule 'CanPrintAsNumber', expected one of: [\\$.0-9−]");
                }
            } while (false);
            // Line 45: ( BinNumber / HexNumber / DecNumber )
            la0 = src.LA0;
            if (la0 == '0')
            {
                switch (src.LA(1))
                {
                case 'B':
                case 'b':
                    BinNumber();
                    break;

                case 'X':
                case 'x':
                {
                    HexNumber();
                    // line 46
                    isHex = true;
                }
                break;

                case -1:
                case '\'':
                case '.':
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case 'E':
                case '_':
                case 'e':
                    DecNumber();
                    break;

                default:
                    src.Error(1, "In rule 'CanPrintAsNumber', expected one of: [\\$'.0-9BEX_bex]");
                    break;
                }
            }
            else if (la0 == '.' || la0 >= '1' && la0 <= '9')
            {
                DecNumber();
            }
            else
            {
                src.Error(0, "In rule 'CanPrintAsNumber', expected one of: [.0-9]");
            }
            src.Match(-1);
            // line 50
            return(msgCounter.ErrorCount == 0 &&
                   !(isHex && (firstTMChar >= 'a' && firstTMChar <= 'f' || firstTMChar >= 'A' && firstTMChar <= 'F')));
        }
Esempio n. 2
0
        public Token NextToken()
        {
            int la0, la1;

            _startIndex = _src.InputPosition;
            _value      = null;
            // Line 108: ( Num | Id | [\^] | [*] | [/] | [+] | [\-] | ([:] [=] | [=]) | [.] [n] [a] [n] | [.] [i] [n] [f] | [(] | [)] | [\t ] )
            do
            {
                la0 = _src.LA0;
                switch (la0)
                {
                case '.':
                {
                    la1 = _src.LA(1);
                    if (la1 >= '0' && la1 <= '9')
                    {
                        goto matchNum;
                    }
                    else if (la1 == 'n')
                    {
                                                        #line 116 "Grammars.ecs"
                        _type = TT.Num;
                                                        #line default
                        _src.Skip();
                        _src.Skip();
                        _src.Match('a');
                        _src.Match('n');
                                                        #line 116 "Grammars.ecs"
                        _value = double.NaN;
                                                        #line default
                    }
                    else if (la1 == 'i')
                    {
                                                        #line 117 "Grammars.ecs"
                        _type = TT.Num;
                                                        #line default
                        _src.Skip();
                        _src.Skip();
                        _src.Match('n');
                        _src.Match('f');
                                                        #line 117 "Grammars.ecs"
                        _value = double.PositiveInfinity;
                                                        #line default
                    }
                    else
                    {
                        goto error;
                    }
                }
                break;

                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                    goto matchNum;

                case '^':
                {
                                                #line 110 "Grammars.ecs"
                    _type = TT.Exp;
                                                #line default
                    _src.Skip();
                }
                break;

                case '*':
                {
                                                #line 111 "Grammars.ecs"
                    _type = TT.Mul;
                                                #line default
                    _src.Skip();
                }
                break;

                case '/':
                {
                                                #line 112 "Grammars.ecs"
                    _type = TT.Div;
                                                #line default
                    _src.Skip();
                }
                break;

                case '+':
                {
                                                #line 113 "Grammars.ecs"
                    _type = TT.Add;
                                                #line default
                    _src.Skip();
                }
                break;

                case '-':
                {
                                                #line 114 "Grammars.ecs"
                    _type = TT.Sub;
                                                #line default
                    _src.Skip();
                }
                break;

                case ':':
                case '=':
                {
                                                #line 115 "Grammars.ecs"
                    _type = TT.Set;
                                                #line default
                    // Line 115: ([:] [=] | [=])
                    la0 = _src.LA0;
                    if (la0 == ':')
                    {
                        _src.Skip();
                        _src.Match('=');
                    }
                    else
                    {
                        _src.Match('=');
                    }
                }
                break;

                case '(':
                {
                                                #line 118 "Grammars.ecs"
                    _type = TT.LParen;
                                                #line default
                    _src.Skip();
                }
                break;

                case ')':
                {
                                                #line 119 "Grammars.ecs"
                    _type = TT.RParen;
                                                #line default
                    _src.Skip();
                }
                break;

                case '\t':
                case ' ':
                {
                                                #line 120 "Grammars.ecs"
                    _type = TT.Space;
                                                #line default
                    _src.Skip();
                }
                break;

                default:
                    if (la0 >= 'A' && la0 <= 'Z' || la0 == '_' || la0 >= 'a' && la0 <= 'z')
                    {
                                                #line 109 "Grammars.ecs"
                        _type = TT.Id;
                                                #line default
                        Id();
                    }
                    else
                    {
                        goto error;
                    }
                    break;
                }
                break;
matchNum:
                {
                                        #line 108 "Grammars.ecs"
                    _type = TT.Num;
                                        #line default
                    Num();
                }
                break;
error:
                {
                                        #line 122 "Grammars.ecs"
                    _type = TT.EOF;
                                        #line default
                    // Line 123: ([^\$])?
                    la0 = _src.LA0;
                    if (la0 != -1)
                    {
                                                #line 123 "Grammars.ecs"
                        _type = TT.Unknown;
                                                #line 123 "Grammars.ecs"
                        _src.Error(0, "Unexpected character");
                                                #line default
                        _src.Skip();
                    }
                }
            } while (false);
                        #line 125 "Grammars.ecs"
            return(new Token {
                Type = _type, Value = _value, StartIndex = _startIndex
            });

                        #line default
        }