BadSourceReader.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.IO;
 
namespace BadScript2.Reader;
 
public class BadSourceReader
{
    private readonly int m_EndIndex;
 
    private readonly string m_Source;
 
    private readonly int m_StartIndex;
 
 
    public BadSourceReader(string fileName, string source, int start, int end)
    {
        FileName = fileName;
        m_Source = source;
 
        if (start < 0 || start >= end)
        {
            throw new ArgumentOutOfRangeException(nameof(start));
        }
 
        if (end > source.Length)
        {
            throw new ArgumentOutOfRangeException(nameof(end));
        }
 
        m_StartIndex = start;
        m_EndIndex = end;
        CurrentIndex = start;
    }
 
    public BadSourceReader(string fileName, string source) : this(fileName, source, 0, source.Length) { }
 
    public string Preview => IsEof() ? "END OF FILE" : Source.Substring(CurrentIndex);
 
    public string Source => m_Source.Substring(m_StartIndex, m_EndIndex - m_StartIndex);
 
    public string FileName { get; }
 
    public int CurrentIndex { get; private set; }
 
    public char CurrentChar => GetCurrentChar();
 
    public void SetPosition(int index)
    {
        CurrentIndex = index;
    }
 
    public static BadSourceReader FromFile(string fileName)
    {
        return new BadSourceReader(fileName, BadFileSystem.ReadAllText(fileName));
    }
 
    public bool IsEof(int offset = 0)
    {
        return CurrentIndex + offset >= m_EndIndex && CurrentIndex + offset >= m_StartIndex;
    }
 
    public BadSourcePosition MakeSourcePosition(int length)
    {
        return MakeSourcePosition(CurrentIndex, length);
    }
 
    public BadSourcePosition MakeSourcePosition(int index, int length)
    {
        return BadSourcePosition.Create(FileName, m_Source, index, length);
    }
 
    public char GetCurrentChar(int offset = 0)
    {
        return IsEof(offset) ? '\0' : m_Source[CurrentIndex + offset];
    }
 
    public void MoveNext()
    {
        CurrentIndex++;
    }
 
    public bool Is(char c, int offset = 0)
    {
        return GetCurrentChar(offset) == c;
    }
 
    public bool Is(string s, int offset = 0)
    {
        for (int i = 0; i < s.Length; i++)
        {
            if (!Is(s[i], offset + i))
            {
                return false;
            }
        }
 
        return true;
    }
 
    public bool Is(params char[] chars)
    {
        return Is(0, chars);
    }
 
    public bool Is(params string[] s)
    {
        return Is(0, s);
    }
 
    public bool Is(int offset, params char[] chars)
    {
        return chars.Any(x => Is(x, offset));
    }
 
    public bool Is(int offset, params string[] s)
    {
        return s.Any(x => Is(x, offset));
    }
 
 
    public BadSourcePosition Eat(char c)
    {
        if (!Is(c))
        {
            throw new BadSourceReaderException(
                $"Expected '{c}' but got '{(IsEof() ? "EOF" : GetCurrentChar())}'",
                MakeSourcePosition(1)
            );
        }
 
        MoveNext();
 
        return MakeSourcePosition(1);
    }
 
    public BadSourcePosition Eat(params char[] c)
    {
        if (!c.Any(x => Is(x)))
        {
            throw new BadSourceReaderException(
                $"Expected '{string.Join("' or '", c)}' but got '{(IsEof() ? "EOF" : GetCurrentChar())}'",
                MakeSourcePosition(1)
            );
        }
 
        MoveNext();
 
        return MakeSourcePosition(1);
    }
 
    public BadSourcePosition Eat(string s)
    {
        int start = CurrentIndex;
 
        for (int i = 0; i < s.Length; i++)
        {
            if (!Is(s[i]))
            {
                throw new BadSourceReaderException(
                    $"Expected '{s}' but got '{(IsEof() ? "EOF" : GetCurrentChar())}'",
                    MakeSourcePosition(start, i)
                );
            }
 
            MoveNext();
        }
 
        return MakeSourcePosition(start, s.Length);
    }
 
    public BadSourcePosition Eat(params string[] s)
    {
        string? str = s.FirstOrDefault(x => Is(x));
 
        if (str == null)
        {
            throw new BadSourceReaderException(
                $"Expected '{string.Join("' or '", s)}' but got '{(IsEof() ? "EOF" : GetCurrentChar())}'",
                MakeSourcePosition(1)
            );
        }
 
        return Eat(str);
    }
 
    public void Seek(char c)
    {
        while (!IsEof() && GetCurrentChar() != c)
        {
            MoveNext();
        }
    }
 
    public void Seek(string s)
    {
        while (!IsEof() && !Is(s))
        {
            MoveNext();
        }
    }
 
    public void Seek(params char[] c)
    {
        while (!IsEof() && !Is(c))
        {
            MoveNext();
        }
    }
 
    public void Seek(params string[] s)
    {
        while (!IsEof() && !Is(s))
        {
            MoveNext();
        }
    }
 
    public void Skip(char c)
    {
        if (Is(c))
        {
            MoveNext();
        }
    }
 
    public void Skip(params char[] c)
    {
        bool exit = false;
 
        while (!exit)
        {
            exit = true;
 
            if (!c.Any(ch => Is(ch)))
            {
                continue;
            }
 
            MoveNext();
            exit = false;
        }
    }
}