private bool Multiplier(ref IEnumerator <Token> enumerator) { Logger.Information("Multiplier"); return(TokensSequence.AnyOf(ref enumerator, true, seq => seq.Id(), seq => seq.Const(), seq => seq.String("(").Check(Expression).String(")"))); }
private bool Def(ref IEnumerator <Token> arg) { Logger.Information("Definition"); return(TokensSequence.Init(ref arg) .String("float") .Id() .Result); }
private bool Operator(ref IEnumerator <Token> arg) { Logger.Information("Operator"); return(TokensSequence.AnyOf(ref arg, true, seq => seq .Label() .String(":") .NewLine() .Check(UnlabeledOperator), seq => seq .Check(UnlabeledOperator))); }
private bool OperatorList(ref IEnumerator <Token> arg) { Logger.Information("List of operators"); var s = TokensSequence.Init(ref arg) .Check(Operator) .Iterative(seq => seq.NewLine(), seq => seq.Check(Operator), true); if (!s.Result) { TokensSequence.Logger.Error($"Error in list of operators on '{arg.Current}'"); } arg = s.ToCompare; return(s.Result); }
private bool IdList(ref IEnumerator <Token> enumerator) { Logger.Information("Id list"); var s = TokensSequence.Init(ref enumerator) .Id() .Iterative(seq => seq.String(","), seq => seq.Id()); if (!s.Result) { TokensSequence.Logger.Error($"Error in id list on '{enumerator.Current}'"); } enumerator = s.ToCompare; return(s.Result); }
private bool LogicalTerm(ref IEnumerator <Token> enumerator) { Logger.Information("Logical term"); var s = TokensSequence.Init(ref enumerator) .Check(LogicalMultiplier) .Iterative(seq => seq.String("and"), seq => seq.Check(LogicalMultiplier)); if (!s.Result) { TokensSequence.Logger.Error($"Error in logical term on '{enumerator.Current}'"); } enumerator = s.ToCompare; return(s.Result); }
private bool DefList(ref IEnumerator <Token> arg) { Logger.Information("Definitions list"); var seq = TokensSequence.Init(ref arg) .Check(Def) .Iterative(subseq => subseq.String(","), subseq => subseq.Check(Def) ); if (!seq.Result) { TokensSequence.Logger.Error($"Error in definition list on '{arg.Current}'"); } arg = seq.ToCompare; return(seq.Result); }
private bool Expression(ref IEnumerator <Token> enumerator) { Logger.Information("Expression"); var s = TokensSequence.Init(ref enumerator) .Check(Term) .Iterative(seq => seq.String("+"), seq => seq.Check(Term)) .Iterative(seq => seq.String("-"), seq => seq.Check(Term)); if (!s.Result) { TokensSequence.Logger.Error($"Error in expression on '{enumerator.Current}'"); } enumerator = s.ToCompare; return(s.Result); }
private bool LogicalMultiplier(ref IEnumerator <Token> enumerator) { Logger.Information("Logical multiplier"); return(TokensSequence.AnyOf(ref enumerator, true, seq => seq.Check(Expression).AnyFrom( innseq => innseq.String(">").Check(Expression), innseq => innseq.String(">=").Check(Expression), innseq => innseq.String("<").Check(Expression), innseq => innseq.String("<=").Check(Expression), innseq => innseq.String("==").Check(Expression), innseq => innseq.String("!=").Check(Expression)), seq => seq.String("[") .Check(LogicalExpression) .String("]"), seq => seq.String("not").Check(LogicalExpression))); }
private bool Root(IEnumerator <Token> tokens) { Logger.Information("Root parsing"); TokensSequence.Logger = Logger; return(TokensSequence.Init(ref tokens) .String("program") .Id() .NewLine() .String("var") .Check(DefList) .NewLine() .String("begin") .NewLine() .Check(OperatorList) .NewLine() .String("end") .Result); }
private bool UnlabeledOperator(ref IEnumerator <Token> enumerator) { Logger.Information("Unlabeled operator"); return(TokensSequence.AnyOf(ref enumerator, true, seq => seq .Id() .String("=") .Check(Expression), seq => seq .String("readl") .String("(") .Check(IdList) .String(")"), seq => seq .String("writel") .String("(") .Check(IdList) .String(")"), seq => seq .String("do") .Id() .String("=") .Check(Expression) .String("to") .Check(Expression) .NewLine() .Check(OperatorList) .NewLine() .String("next"), seq => seq .String("if") .Check(LogicalExpression) .String("then") .String("goto") .Label())); }