Example #1
0
 public void SetElements(GrammarElement element)
 {
     Element = element;
 }
Example #2
0
 public GrammarRule(GrammarElement element)
 {
     Name = "Implicit"; Element = element; Cardinality = 1;
 }
Example #3
0
 public GrammarRule(string name, GrammarElement element)
 {
     Name = name; Element = element; Cardinality = 1;
 }
Example #4
0
        // Called recursively to generate tokens/instructions from a source code string
        public static IEnumerable <string> Parse(string source, ref int sourceI, GrammarElement element, ParseContext context)
        {
            IEnumerable <string> res = null;

            if (element is GrammarElementA)
            {
                var elA  = element as GrammarElementA;
                int iter = sourceI;
                using (var level = context.GetCurrentContext()) {
                    for (int e = 0; e < elA.Elements.Length; ++e)
                    {
                        var ok = Parse(source, ref iter, elA.Elements[e], context);
                        if (ok == null)
                        {
                            level.RemoveChanges();
                            return(null);
                        }
                        if (res == null)
                        {
                            res = ok;
                        }
                        else
                        {
                            res = res.Concat(ok);
                        }
                    }
                }
                sourceI = iter;
            }
            else if (element is GrammarElementO)
            {
                var elA = element as GrammarElementO;
                for (int e = 0; e < elA.Elements.Length; ++e)
                {
                    int iter = sourceI;
                    var ok   = Parse(source, ref iter, elA.Elements[e], context);
                    if (ok != null)
                    {
                        sourceI = iter; res = ok; break;
                    }
                }
            }
            else if (element is GrammarElementT)
            {
                ParserUtil.IteratePastWhitespaceAndComments(source, ref sourceI);
                var elA   = element as GrammarElementT;
                var token = elA.TokenType;
                int match = token.Match(source, sourceI);
                if (match < 0)
                {
                    context.MarkError(sourceI, token);
                    return(null);
                }
                sourceI += match;
                return(new string[] { token.Name });
            }
            else if (element is GrammarElementR)
            {
                var elA  = element as GrammarElementR;
                var rule = elA.Rule;

                ParserUtil.IteratePastWhitespaceAndComments(source, ref sourceI);
                int  sourceS    = sourceI;
                int  iter       = sourceI;
                bool isImplicit = rule.Name == "Implicit";
                isImplicit = false;
                ParseContext.Level level = new ParseContext.Level();
                if (!isImplicit)
                {
                    context.PushRule(rule);
                    level = context.GetCurrentContext();
                }
                for (int r = 1; r <= rule.Cardinality.To; ++r)
                {
                    if (!isImplicit)
                    {
                        level.ClearChildren();
                    }
                    var ok = Parse(source, ref iter, rule.Element, context);
                    if (ok != null)
                    {
                        if (!isImplicit)
                        {
                            if (rule.Build != null)
                            {
                                SourceIterator sourceIter = new SourceIterator(source, sourceI, iter);
                                rule.Build(level, sourceIter);
                            }
                            else
                            {
                                level.PassThrough();
                            }
                        }
                        if (r >= rule.Cardinality.From)
                        {
                            if (res == null)
                            {
                                res = ok;
                            }
                            else
                            {
                                res = res.Concat(ok);
                            }
                            sourceI = iter;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                if (res == null && rule.Cardinality.From == 0)
                {
                    res = new string[] { };
                }
                if (!isImplicit)
                {
                    context.PopRule(rule);
                    if (res == null)
                    {
                        level.RemoveChanges();
                    }
                    level.Dispose();
                }
            }
            return(res);
        }
 public void SetElements(GrammarElement element) {
     Element = element;
 }
 public GrammarRule(string name, GrammarElement element) { Name = name; Element = element; Cardinality = 1; }
 public GrammarRule(GrammarElement element) { Name = "Implicit"; Element = element; Cardinality = 1; }
Example #8
0
        // Called recursively to generate tokens/instructions from a source code string
        public static IEnumerable<string> Parse(string source, ref int sourceI, GrammarElement element, ParseContext context)
        {
            IEnumerable<string> res = null;
            if (element is GrammarElementA) {
                var elA = element as GrammarElementA;
                int iter = sourceI;
                using (var level = context.GetCurrentContext()) {
                    for (int e = 0; e < elA.Elements.Length; ++e) {
                        var ok = Parse(source, ref iter, elA.Elements[e], context);
                        if (ok == null) {
                            level.RemoveChanges();
                            return null;
                        }
                        if (res == null) res = ok; else res = res.Concat(ok);
                    }
                }
                sourceI = iter;
            } else if (element is GrammarElementO) {
                var elA = element as GrammarElementO;
                for (int e = 0; e < elA.Elements.Length; ++e) {
                    int iter = sourceI;
                    var ok = Parse(source, ref iter, elA.Elements[e], context);
                    if (ok != null) { sourceI = iter; res = ok; break; }
                }
            } else if (element is GrammarElementT) {
                ParserUtil.IteratePastWhitespaceAndComments(source, ref sourceI);
                var elA = element as GrammarElementT;
                var token = elA.TokenType;
                int match = token.Match(source, sourceI);
                if (match < 0) {
                    context.MarkError(sourceI, token);
                    return null;
                }
                sourceI += match;
                return new string[] { token.Name };
            } else if (element is GrammarElementR) {
                var elA = element as GrammarElementR;
                var rule = elA.Rule;

                ParserUtil.IteratePastWhitespaceAndComments(source, ref sourceI);
                int sourceS = sourceI;
                int iter = sourceI;
                bool isImplicit = rule.Name == "Implicit";
                isImplicit = false;
                ParseContext.Level level = new ParseContext.Level();
                if (!isImplicit) {
                    context.PushRule(rule);
                    level = context.GetCurrentContext();
                }
                for (int r = 1; r <= rule.Cardinality.To; ++r) {
                    if (!isImplicit) level.ClearChildren();
                    var ok = Parse(source, ref iter, rule.Element, context);
                    if (ok != null) {
                        if (!isImplicit) {
                            if (rule.Build != null) {
                                SourceIterator sourceIter = new SourceIterator(source, sourceI, iter);
                                rule.Build(level, sourceIter);
                            } else {
                                level.PassThrough();
                            }
                        }
                        if (r >= rule.Cardinality.From) {
                            if (res == null) res = ok; else res = res.Concat(ok);
                            sourceI = iter;
                        }
                    } else break;
                }
                if (res == null && rule.Cardinality.From == 0) {
                    res = new string[] { };
                }
                if (!isImplicit) {
                    context.PopRule(rule);
                    if (res == null) level.RemoveChanges();
                    level.Dispose();
                }
            }
            return res;
        }