BadSourceReaderExtensions.cs

Go to the documentation of this file.

using System.Text;
using System.Text.RegularExpressions;
 
using BadScript2.Common;
using BadScript2.Reader.Token;
using BadScript2.Reader.Token.Primitive;
 
namespace BadScript2.Reader;
 
public static class BadSourceReaderExtensions
{
    public static bool IsWordStart(this BadSourceReader reader, int offset = 0)
    {
        return char.IsLetter(reader.GetCurrentChar(offset)) ||
               reader.GetCurrentChar(offset) == '_';
    }
 
    public static bool IsWordChar(this BadSourceReader reader, int offset = 0)
    {
        return char.IsLetterOrDigit(reader.GetCurrentChar(offset)) ||
               reader.GetCurrentChar(offset) == '_';
    }
 
    public static bool IsKey(this BadSourceReader reader, char c, int offset = 0)
    {
        return reader.Is(c, offset) && !reader.IsWordChar(offset + 1);
    }
 
    public static bool IsKey(this BadSourceReader reader, string s, int offset = 0)
    {
        return reader.Is(s, offset) && !reader.IsWordChar(offset + s.Length);
    }
 
    public static bool IsStringQuote(this BadSourceReader reader, int offset = 0, bool singleQuote = false)
    {
        if (singleQuote)
        {
            return reader.GetCurrentChar(offset) == BadStaticKeys.SINGLE_QUOTE;
        }
 
        return reader.GetCurrentChar(offset) == BadStaticKeys.QUOTE;
    }
 
    public static bool IsNumberStart(this BadSourceReader reader, int offset = 0)
    {
        return reader.IsDigit(offset) ||
               reader.GetCurrentChar(offset) == BadStaticKeys.DECIMAL_SEPARATOR;
    }
 
    public static bool IsDigit(this BadSourceReader reader, int offset = 0)
    {
        return char.IsDigit(reader.GetCurrentChar(offset));
    }
 
    public static bool IsNewLine(this BadSourceReader reader, int offset = 0)
    {
        return reader.Is(offset, BadStaticKeys.NewLine);
    }
 
    public static void SkipWhiteSpace(this BadSourceReader reader)
    {
        reader.Skip(BadStaticKeys.Whitespace);
    }
 
 
    public static void SkipNewLine(this BadSourceReader reader)
    {
        reader.Skip(BadStaticKeys.NewLine);
    }
 
    public static void SkipToEndOfLine(this BadSourceReader reader)
    {
        reader.Seek(BadStaticKeys.NewLine);
    }
 
    public static void SkipWhiteSpaceAndNewLine(this BadSourceReader reader)
    {
        reader.Skip(BadStaticKeys.Whitespace.Concat(BadStaticKeys.NewLine)
                                 .ToArray()
                   );
    }
 
    public static void SkipComment(this BadSourceReader reader)
    {
        if (reader.Is(BadStaticKeys.SINGLE_LINE_COMMENT))
        {
            reader.Eat(BadStaticKeys.SINGLE_LINE_COMMENT);
            reader.SkipToEndOfLine();
            reader.SkipNewLine();
        }
        else if (reader.Is(BadStaticKeys.MULTI_LINE_COMMENT_START))
        {
            reader.Eat(BadStaticKeys.MULTI_LINE_COMMENT_START);
            reader.Seek(BadStaticKeys.MULTI_LINE_COMMENT_END);
            reader.Eat(BadStaticKeys.MULTI_LINE_COMMENT_END);
        }
    }
 
    public static void SkipNonToken(this BadSourceReader reader)
    {
        int current;
 
        do
        {
            current = reader.CurrentIndex;
            reader.SkipComment();
            reader.SkipWhiteSpaceAndNewLine();
        }
        while (current != reader.CurrentIndex);
    }
 
 
    public static BadWordToken ParseWord(this BadSourceReader reader)
    {
        if (!reader.IsWordStart())
        {
            throw new
                BadSourceReaderException($"Expected word start character but got '{(reader.IsEof() ? "EOF" : reader.GetCurrentChar())}'",
                                         reader.MakeSourcePosition(1)
                                        );
        }
 
        int start = reader.CurrentIndex;
        reader.MoveNext();
 
        while (reader.IsWordChar())
        {
            reader.MoveNext();
        }
 
        return new BadWordToken(reader.MakeSourcePosition(start, reader.CurrentIndex - start));
    }
 
    public static BadNumberToken ParseNumber(this BadSourceReader reader)
    {
        if (!reader.IsNumberStart())
        {
            throw new
                BadSourceReaderException($"Expected number start character but got '{(reader.IsEof() ? "EOF" : reader.GetCurrentChar())}'",
                                         reader.MakeSourcePosition(1)
                                        );
        }
 
        int start = reader.CurrentIndex;
        reader.MoveNext();
        bool hasDecimal = false;
 
        while (reader.IsDigit() || (!hasDecimal && reader.Is(BadStaticKeys.DECIMAL_SEPARATOR)))
        {
            if (reader.Is(BadStaticKeys.DECIMAL_SEPARATOR))
            {
                hasDecimal = true;
            }
 
            reader.MoveNext();
        }
 
        if (reader.Last(BadStaticKeys.DECIMAL_SEPARATOR))
        {
            reader.SetPosition(reader.CurrentIndex - 1);
        }
 
        return new BadNumberToken(reader.MakeSourcePosition(start, reader.CurrentIndex - start));
    }
 
    public static BadBooleanToken ParseBoolean(this BadSourceReader reader)
    {
        if (reader.Is(BadStaticKeys.TRUE))
        {
            return new BadBooleanToken(reader.Eat(BadStaticKeys.TRUE));
        }
 
        if (reader.Is(BadStaticKeys.FALSE))
        {
            return new BadBooleanToken(reader.Eat(BadStaticKeys.FALSE));
        }
 
        throw new
            BadSourceReaderException($"Expected boolean but got '{(reader.IsEof() ? "EOF" : reader.GetCurrentChar())}'",
                                     reader.MakeSourcePosition(1)
                                    );
    }
 
    public static BadNullToken ParseNull(this BadSourceReader reader)
    {
        return new BadNullToken(reader.Eat(BadStaticKeys.NULL));
    }
 
    public static BadSymbolToken? TryParseSymbols(this BadSourceReader reader, string symbols)
    {
        return reader.Is(symbols) ? new BadSymbolToken(reader.Eat(symbols)) : null;
    }
 
    public static BadSymbolToken? TryParseSymbols(this BadSourceReader reader, IEnumerable<string> symbols)
    {
        string? symbol =
            symbols.FirstOrDefault(x => x.All(c => char.IsLetter(c) || c == '_') ? reader.IsKey(x) : reader.Is(x));
 
        return symbol == null ? null : reader.TryParseSymbols(symbol);
    }
 
    public static BadStringToken ParseString(this BadSourceReader reader)
    {
        if (!reader.IsStringQuote() && !reader.IsStringQuote(0, true))
        {
            throw new
                BadSourceReaderException($"Expected string start character but got '{(reader.IsEof() ? "EOF" : reader.GetCurrentChar())}'",
                                         reader.MakeSourcePosition(1)
                                        );
        }
 
        bool singleQuote = reader.Is(BadStaticKeys.SINGLE_QUOTE);
        int start = reader.CurrentIndex;
        reader.MoveNext();
        bool isEscaped = false;
        StringBuilder sb = new StringBuilder("\"");
 
        while (!reader.IsStringQuote(0, singleQuote))
        {
            if (reader.IsNewLine() || reader.IsEof())
            {
                throw new BadSourceReaderException("String not terminated",
                                                   reader.MakeSourcePosition(start, reader.CurrentIndex - start)
                                                  );
            }
 
            if (reader.Is(BadStaticKeys.ESCAPE_CHARACTER))
            {
                isEscaped = true;
                reader.MoveNext();
            }
 
            if (isEscaped)
            {
                isEscaped = false;
                sb.Append(Regex.Unescape($"\\{reader.GetCurrentChar()}"));
            }
            else
            {
                sb.Append(reader.GetCurrentChar());
            }
 
            reader.MoveNext();
        }
 
        reader.Eat(singleQuote ? BadStaticKeys.SINGLE_QUOTE : BadStaticKeys.QUOTE);
 
        sb.Append("\"");
 
        return new BadStringToken(sb.ToString(), reader.MakeSourcePosition(start, reader.CurrentIndex - start));
    }
 
    public static BadStringToken ParseMultiLineString(this BadSourceReader reader)
    {
        int start = reader.CurrentIndex;
        reader.Eat(BadStaticKeys.MULTI_LINE_STRING_KEY);
 
        StringBuilder sb = new StringBuilder("\"");
 
        while (!reader.IsStringQuote())
        {
            if (reader.IsEof())
            {
                throw new BadSourceReaderException("String not terminated",
                                                   reader.MakeSourcePosition(start, reader.CurrentIndex - start)
                                                  );
            }
 
            sb.Append(reader.GetCurrentChar());
 
            reader.MoveNext();
        }
 
        reader.Eat(BadStaticKeys.QUOTE);
 
        sb.Append("\"");
 
        return new BadStringToken(sb.ToString(), reader.MakeSourcePosition(start, reader.CurrentIndex - start));
    }
 
    public static bool IsWhiteSpace(this BadSourceReader reader, int offset = 0)
    {
        return reader.Is(offset, BadStaticKeys.Whitespace) ||
               reader.Is(offset, BadStaticKeys.NewLine);
    }
 
    public static bool Last(this BadSourceReader reader, char c)
    {
        int index = -1;
 
        while (reader.IsWhiteSpace(index))
        {
            index--;
        }
 
        return reader.GetCurrentChar(index) == c;
    }
}