ScriptParser.cs

using Waher.Script.Exceptions;
using Waher.Script.Units;
 
namespace Waher.Script.Model
{
    public class ScriptParser
    {
        private readonly Expression expression;
        private readonly int start;
 
        internal ScriptParser(Expression Expression, int Start)
        {
            this.start = Start;
            this.expression = Expression;
        }
 
        public int Start => this.start;
 
        public int Length => this.expression.Position - this.start;
 
        public int Position => this.expression.Position;
 
        public Expression Expression => this.expression;
 
        public bool CanSkipWhitespace
        {
            get => this.expression.CanSkipWhitespace;
            set => this.expression.CanSkipWhitespace = value;
        }
 
        public char NextChar() => this.expression.NextChar();
 
        public char NextNonWhitespaceChar()
        {
            char ch;
 
            do
            {
                ch = this.NextChar();
            }
            while (ch != 0 && char.IsWhiteSpace(ch));
 
            return ch;
        }
 
        public void UndoChar()
        {
            this.expression.UndoChar();
        }
 
        public string PeekNextChars(int NrChars)
        {
            return this.expression.PeekNextChars(NrChars);
        }
 
        public bool IsNextChars(string Token)
        {
            return this.expression.IsNextChars(Token);
        }
 
        public bool IsNextChars(char ch, int Count)
        {
            return this.expression.IsNextChars(ch, Count);
        }
 
        public void SkipChars(int NrChars)
        {
            this.expression.SkipChars(NrChars);
        }
 
        public char PeekNextChar() => this.expression.PeekNextChar();
 
        public string NextToken() => this.expression.NextToken();
 
        public string PeekNextToken() => this.expression.PeekNextToken();
 
        public void SkipWhiteSpace() => this.expression.SkipWhiteSpace();
 
        public ScriptNode AssertOperandNotNull(ScriptNode Node) => this.expression.AssertOperandNotNull(Node);
 
        public ScriptNode AssertRightOperandNotNull(ScriptNode Node) => this.expression.AssertRightOperandNotNull(Node);
 
        public ScriptNode ParseSequence() => this.expression.ParseSequence();
 
        public ScriptNode ParseStatement() => this.expression.ParseStatement(false);
 
        public ScriptNode ParseList() => this.expression.ParseList();
 
        public ScriptNode ParseIf() => this.expression.ParseIf();
 
        public ScriptNode ParseAssignments() => this.expression.ParseAssignments();
 
        public ScriptNode ParseLambdaExpression() => this.expression.ParseLambdaExpression();
 
        public ScriptNode ParseEquivalence() => this.expression.ParseEquivalence();
 
        public ScriptNode ParseOrs() => this.expression.ParseOrs();
 
        public ScriptNode ParseAnds() => this.expression.ParseAnds();
 
        public ScriptNode ParseMembership() => this.expression.ParseMembership();
 
        public ScriptNode ParseComparison() => this.expression.ParseComparison();
 
        public ScriptNode ParseShifts() => this.expression.ParseShifts();
 
        public ScriptNode ParseUnions() => this.expression.ParseUnions();
 
        public ScriptNode ParseIntersections() => this.expression.ParseIntersections();
 
        public ScriptNode ParseInterval() => this.expression.ParseInterval();
 
        public ScriptNode ParseTerms() => this.expression.ParseTerms();
 
        public ScriptNode ParseBinomialCoefficients() => this.expression.ParseBinomialCoefficients();
 
        public ScriptNode ParseFactors() => this.expression.ParseFactors();
 
        public ScriptNode ParsePowers() => this.expression.ParsePowers();
 
        public ScriptNode ParseUnaryPrefixOperator() => this.expression.ParseUnaryPrefixOperator();
 
        public ScriptNode ParseSuffixOperator() => this.expression.ParseSuffixOperator();
 
        public Unit ParseUnit(bool PermitPrefix) => this.expression.ParseUnit(PermitPrefix);
 
        public ScriptNode ParseObject() => this.expression.ParseObject();
 
        public bool EndOfScript => this.expression.EndOfScript;
 
        public bool InScript => this.expression.InScript;
 
        public bool HasCharacters(int NrCharacters) => this.expression.Position <= this.expression.Script.Length - NrCharacters;
 
        public SyntaxException SyntaxError(string Message)
        {
            return new SyntaxException(Message, this.Position, this.expression.Script);
        }
    }
}