Example #1
0
        public override void GramerAccept(GramerInfo gramerInfo)
        {
            var color = Console.ForegroundColor;

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine(gramerInfo.Symbol.Name + "," + gramerInfo.Value);
            Console.ForegroundColor = color;
        }
Example #2
0
        public override void GramerRead(GramerInfo gramerInfo)
        {
            var color = Console.ForegroundColor;

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine(new string(' ', gramerInfo.Level * 3) + gramerInfo.Level + ":" + gramerInfo.Symbol.Name +
                              "," + gramerInfo.Value + "$");
            Console.ForegroundColor = color;
        }
Example #3
0
 public virtual void GramerAccept(GramerInfo gramerInfo)
 {
 }
Example #4
0
 public virtual void GramerRead(GramerInfo gramerInfo)
 {
 }
Example #5
0
        public void Analy(string val)
        {
            _ResultGramerInfo = null;

            var tokenReader  = new TokenReader(_EgtManager, val);
            var gramerReader = new GramerReader(_EgtManager);

            while (true)
            {
                var token = tokenReader.ReadToken();
                TokenRead(token);

                if (token.Symbol == null || token.Symbol.Type != SymbolType.Noise)
                {
                    while (true)
                    {
                        var gramer = gramerReader.ReadGramer(token);

                        if (gramer.GramerState == GramerInfoState.Reduce)
                        {
                            var gramerVal = val.Substring(gramer.Index, token.Index - gramer.Index);

                            if (ContentNameGroup.Contains(gramer.Symbol.Name))
                            {
                                var preWhiteSpace = val.MatchPre(@"\s+", gramer.Index - 1);

                                if (preWhiteSpace != null)
                                {
                                    gramerVal = preWhiteSpace + gramerVal;
                                    var newPoint = val.PrePoint(new LinePoint(gramer.Index, gramer.Col, gramer.Line),
                                                                preWhiteSpace.Length);
                                    gramer.Index = newPoint.Index;
                                    gramer.Line  = newPoint.Y;
                                    gramer.Col   = newPoint.X;
                                }
                                gramer.Value = gramerVal;
                                //index,line,col
                            }
                            else
                            {
                                gramerVal    = gramerVal.Trim();
                                gramer.Value = gramerVal;
                            }

                            GramerRead(gramer);
                        }
                        else if (gramer.GramerState == GramerInfoState.Accept)
                        {
                            _ResultGramerInfo = gramer.ChildGroup[0];
                            GramerAccept(gramer);
                        }

                        if (gramer.GramerState != GramerInfoState.Reduce)
                        {
                            break;
                        }
                    }
                }

                if (token.State == TokenInfoState.End)
                {
                    break;
                }
            }
        }
Example #6
0
        public GramerInfo ReadGramer(TokenInfo tokenInfo)
        {
            var curStrate = _GrammerGroup.Peek().Item1;
            var action    = curStrate.GetAction(tokenInfo.Symbol);

            if (action == null)
            {
                return(new GramerInfo(GramerInfoState.Error, tokenInfo));
            }
            else
            {
                if (action.ActionType == ActionType.Shift)
                {
                    var gramerSymbol = new GramerInfo(GramerInfoState.Shift, tokenInfo);
                    _GrammerGroup.Push(new Tuple <LALRState, GramerInfo>(action.TargetState, gramerSymbol));

                    return(gramerSymbol);
                }
                else if (action.ActionType == ActionType.Reduce)
                {
                    var produce         = action.TargetRule;
                    var prodSymbolCount = produce.SymbolGroup.Count;

                    var group = EnumerableHelper.For(prodSymbolCount)
                                .Select(item => _GrammerGroup.Pop())
                                .Reverse()
                                .ToList();
                    var gramerSymbol = new GramerInfo(GramerInfoState.Reduce,
                                                      group.Count > 0
                            ? group.First().Item2.StartToken
                            : new TokenInfo(TokenInfoState.Accept, null, null, tokenInfo.Index, tokenInfo.Line,
                                            tokenInfo.Col))
                    {
                        ChildGroup = group.Select(item => item.Item2).ToList(),
                        Value      = group.JoinStr(string.Empty, item => item.Item2.Value),
                        Symbol     = produce.NonTerminal,
                        Produce    = produce
                    };

                    _GrammerGroup.Push(new Tuple <LALRState, GramerInfo>(_GrammerGroup.Peek().Item1.GetAction(produce.NonTerminal).TargetState, gramerSymbol));

                    return(gramerSymbol);
                }
                else if (action.ActionType == ActionType.Accept)
                {
                    var gramerInfo = _GrammerGroup.Peek().Item2;

                    var gramerSymbol = new GramerInfo(GramerInfoState.Accept, tokenInfo)
                    {
                        ChildGroup = new List <GramerInfo>()
                        {
                            gramerInfo
                        },
                        Value = gramerInfo.Value,
                        Data  = gramerInfo.Data
                    };

                    return(gramerSymbol);
                }
                else
                {
                    throw new NotSupportedException();
                }
            }
        }