/// <summary> /// Decorates given parser rule with all necessary global parser rules. /// </summary> /// <param name="rule">Parser rule to decorate</param> /// <returns>Given parser rule decorated with all necessary global rules.</returns> private IParserRule <TToken> DecorateWithGlobalRules(IParserRule <TToken> rule) { return (ExcludedGlobalRules == AllGlobalRules ? rule : new GlobalRulesDecoratorRule <TToken>(rule, ExcludedGlobalRules)); }
public SidesOrNoSidesRule( IParserRule <IBuildConflict> sidesDefinedFollowUpRule, IParserRule <IBuildConflict> noSidesDefinedFollowUpRule) { this.sidesDefinedFollowUpRule = sidesDefinedFollowUpRule; this.noSidesDefinedFollowUpRule = noSidesDefinedFollowUpRule; }
/// <summary> /// Extracts underlying parser rule from the given decorator. /// </summary> /// <param name="rule">Potential decorator rule</param> /// <returns>Underlying parser rule or original rule, if given rule is not decorated.</returns> public static IParserRule <TToken> Unwrap(IParserRule <TToken> rule) { var decoratedRule = rule as GlobalRulesDecoratorRule <TToken>; return (decoratedRule == null ? rule : decoratedRule.rule); }
/// <summary> /// Intializes a new instance of the <see cref="GlobalRulesDecoratorRule{TToken}"/> class /// with the provided underlying rule and collection of excluded global rules. /// </summary> /// <param name="rule">Underlying parser rule</param> /// <param name="excludedGlobalRules">Set of excluded global rules</param> public GlobalRulesDecoratorRule( IParserRule <TToken> rule, ISet <string> excludedGlobalRules) { this.rule = rule ?? throw new ArgumentNullException(nameof(rule)); this.excludedGlobalRules = excludedGlobalRules; }
public ParserNode(TagType tagType, int startPosition, int endPosition, IParserRule rule) { childs = new List <ParserNode>(); TypeTag = tagType; StartPosition = startPosition; EndPosition = endPosition; StartInnerPartPosition = startPosition + rule.OpenTag.Length; EndInnerPartPosition = endPosition - rule.CloseTag.Length; attributes = new Dictionary <string, string>(); }
/// <summary> /// Adds a parser rule to the grammar. /// </summary> /// <param name="rule">Instance of the parser rule implementation</param> /// <param name="isGlobal">Flag that indicates whether parser rule is global</param> public void AddRule(IParserRule <TToken> rule, bool isGlobal = false) { if (isGlobal) { globalRules[rule.RuleName] = rule; globalRulesCache = null; } else { rules[rule.RuleName] = rule; } }
public SplitByDashIntoSeparateSides(IParserRule <IBuildSide> followUpRule) { Argument.AssertIsNotNull(followUpRule, nameof(followUpRule)); this.followUpRule = followUpRule; }
public RemoveNumericBlocksAtTheEndRule(IParserRule <IBuildConflict> followUpRule) { Argument.AssertIsNotNull(followUpRule, nameof(followUpRule)); this.followUpRule = followUpRule; }
/// <summary> /// Initializes a new instance of the <see cref="OneOrMoreTimesRule{TToken}"/> class /// with the provided parser rule. /// </summary> /// <param name="rule">Parser rule to match</param> public OneOrMoreTimesRule(IParserRule <TToken> rule) : base(rule) { }
public TemplateParser(Dictionary <char, IParserRule> parseRules, IParserRule fallbackRule, IMessageHandler messageHandler) { this.ParseRules = parseRules; this.FallbackRule = fallbackRule; this.MessageHandler = messageHandler; }
public TemplateParser(Dictionary<char, IParserRule> parseRules, IParserRule fallbackRule, IMessageHandler messageHandler) { this.parseRules = parseRules; this.fallbackRule = fallbackRule; this.messageHandler = messageHandler; }
/// <summary> /// Initializes a new instance of the <see cref="OptionalRule{TToken}"/> class /// with the provided parser rule. /// </summary> /// <param name="rule">Parser rule to match</param> public OptionalRule(IParserRule <TToken> rule) { this.rule = rule ?? throw new ArgumentNullException(nameof(rule)); }
/// <summary> /// Creates logical parser rule that matches one or more occurences of the given rule. /// </summary> /// <param name="rule">Parser rule to match</param> /// <returns>New parser rule that implements one-or-more-times logic.</returns> protected IParserRule <TToken> OneOrMoreTimes(IParserRule <TToken> rule) { return(new OneOrMoreTimesRule <TToken>(rule)); }
/// <summary> /// Creates logical parser rule that matches given rule zero or one time, making it optional. /// </summary> /// <param name="rule">Parser rule to match</param> /// <returns>New parser rule that implements optional match logic.</returns> protected IParserRule <TToken> Optional(IParserRule <TToken> rule) { return(new OptionalRule <TToken>(rule)); }
/// <summary> /// Checks, if specified global <paramref name="rule"/> should be included in matching. /// </summary> /// <param name="rule">Global rule to check</param> /// <returns>true if rule should be included, otherwise false.</returns> private bool IsIncludedGlobalRule(IParserRule <TToken> rule) { return(!excludedGlobalRules.Contains(rule.RuleName)); }
/// <summary> /// Initializes a new instance of the <see cref="RepetitiveRuleBase{TToken}"/> class /// with the provided parser rule. /// </summary> /// <param name="rule">Parser rule to match</param> public RepetitiveRuleBase(IParserRule <TToken> rule) { Rule = rule ?? throw new ArgumentNullException(nameof(rule)); }