Brychan Dempsey
51920ef69e
All checks were successful
continuous-integration/appveyor/branch AppVeyor build succeeded
910 lines
39 KiB
C#
910 lines
39 KiB
C#
/* Dempsey-Jensen, Brychan, 14299890, Assignment 1, 159.341 */
|
|
/* Parses and interprets a simple programming language line-by-line */
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
namespace Assignment_1
|
|
{
|
|
class Program
|
|
{
|
|
/// <summary>
|
|
/// Flags to set symbol properties
|
|
/// </summary>
|
|
[Flags]
|
|
enum VariableFlags
|
|
{
|
|
Empty = 0,
|
|
Reserved = 1,
|
|
NoPrint = 2,
|
|
Static = 4
|
|
}
|
|
static readonly int ConsoleWidthLimit = 80;
|
|
|
|
static void Main(string[] args)
|
|
{
|
|
Console.WriteLine(CenterString("┌──────────────────────────────────────────┐", ConsoleWidthLimit));
|
|
Console.WriteLine(CenterString("│ 159.341 2021 Semester 1, Assignment 1 │", ConsoleWidthLimit));
|
|
Console.WriteLine(CenterString("│ Submitted by Brychan Dempsey, 14299890 │", ConsoleWidthLimit));
|
|
Console.WriteLine(CenterString("└──────────────────────────────────────────┘", ConsoleWidthLimit));
|
|
bool loadedFromFile = false;
|
|
bool exit = false;
|
|
while (!exit)
|
|
{
|
|
MemoryStream sourceStream = new MemoryStream(1024);
|
|
Parser parser = new Parser();
|
|
bool dynamicInput = false;
|
|
// From https://stackoverflow.com/questions/3453220/how-to-detect-if-console-in-stdin-has-been-redirected
|
|
// Reading from pipes is equivalent to reading user input, but the input is redirected
|
|
if (Console.IsInputRedirected || loadedFromFile)
|
|
{
|
|
// To simplify reading, we read all input bytes from the piped input to the stream.
|
|
// Not the best way to do it; we don't need to keep any data that has already been read and parsed successfully.
|
|
sourceStream.Write(Encoding.UTF8.GetBytes(Console.In.ReadToEnd()));
|
|
Console.In.Dispose();
|
|
Console.SetIn(new StreamReader(Console.OpenStandardInput()));
|
|
Console.OpenStandardInput();
|
|
sourceStream.Position = 0;
|
|
}
|
|
else
|
|
{
|
|
sourceStream.Position = 0;
|
|
dynamicInput = true;
|
|
}
|
|
parser.StartParsing(sourceStream, dynamicInput);
|
|
Console.WriteLine(Environment.NewLine + new string('─', 40));
|
|
Console.WriteLine("\nProgram Parsed Successfully!");
|
|
|
|
if (Console.IsInputRedirected)
|
|
{
|
|
Thread.Sleep(3000);
|
|
Environment.Exit(0);
|
|
}
|
|
ConsoleKeyInfo ck = new ConsoleKeyInfo();
|
|
while (ck.Key != ConsoleKey.Y && ck.Key != ConsoleKey.N)
|
|
{
|
|
Console.WriteLine("\nWould you like to parse another program? Y/n:");
|
|
ck = Console.ReadKey(true);
|
|
}
|
|
if (ck.Key == ConsoleKey.N)
|
|
{
|
|
exit = true;
|
|
}
|
|
else
|
|
{
|
|
// Need the logic to prep the next source stream
|
|
ck = new ConsoleKeyInfo();
|
|
while (ck.Key != ConsoleKey.Y && ck.Key != ConsoleKey.N)
|
|
{
|
|
Console.WriteLine("\nWould you like to pipe data from a source file? Y/n:");
|
|
ck = Console.ReadKey(true);
|
|
}
|
|
if (ck.Key == ConsoleKey.N)
|
|
{
|
|
// Set the input to standard input stream
|
|
Console.SetIn(Console.In);
|
|
loadedFromFile = false;
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Enter the source path:");
|
|
string sourcePath = Console.ReadLine();
|
|
if (File.Exists(sourcePath))
|
|
{
|
|
try
|
|
{
|
|
Console.SetIn(File.OpenText(sourcePath));
|
|
loadedFromFile = true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("Encountered an error opening the source file: " + e.Message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class Parser
|
|
{
|
|
Dictionary<string, Tuple<string, VariableFlags>> Symbols = new Dictionary<string, Tuple<string, VariableFlags>>()
|
|
{
|
|
{ "SPACE", new Tuple<string, VariableFlags>(" ", VariableFlags.Reserved | VariableFlags.NoPrint) },
|
|
{ "TAB", new Tuple<string, VariableFlags>("\t", VariableFlags.Reserved | VariableFlags.NoPrint) },
|
|
{ "NEWLINE", new Tuple<string, VariableFlags>("\n", VariableFlags.Reserved | VariableFlags.NoPrint) },
|
|
{ "CARRIAGE_RETURN", new Tuple<string, VariableFlags>("\r", VariableFlags.Reserved | VariableFlags.NoPrint) }
|
|
};
|
|
|
|
public enum Statements
|
|
{
|
|
exit,
|
|
append,
|
|
list,
|
|
print,
|
|
printlength,
|
|
printwords,
|
|
printwordcount,
|
|
set,
|
|
reverse,
|
|
h,
|
|
writeout
|
|
}
|
|
public void StartParsing(Stream source, bool dynamicInput = false)
|
|
{
|
|
long initSourceLength = source.Length;
|
|
long lastLinePos = 0;
|
|
long initPos = 0;
|
|
bool cont = false;
|
|
while (true)
|
|
{
|
|
if (dynamicInput)
|
|
{
|
|
lastLinePos = source.Position;
|
|
if (!cont)
|
|
{
|
|
Console.WriteLine("Enter a command: ");
|
|
}
|
|
string s = Console.ReadLine();
|
|
long pos = source.Position;
|
|
source.Write(Encoding.UTF8.GetBytes(s));
|
|
source.Position = pos;
|
|
|
|
}
|
|
// parse the statement or list of statements;
|
|
// This is done by reading the next word
|
|
if (!cont)
|
|
{
|
|
initPos = source.Position;
|
|
}
|
|
else
|
|
{
|
|
source.Position = initPos;
|
|
}
|
|
SkipWhitespace(source);
|
|
long position = FindNextWord(source, out string word);
|
|
try
|
|
{
|
|
if (Enum.TryParse(typeof(Statements), word, out object statementType))
|
|
{
|
|
// By turning the result of the command into an action,
|
|
// we can defer processing the final result until the end of this control flow
|
|
Action result = () => { };
|
|
source.Position = position;
|
|
switch ((Statements)statementType)
|
|
{
|
|
case Statements.exit:
|
|
result = Exit(source, initSourceLength, dynamicInput);
|
|
break;
|
|
case Statements.append:
|
|
result = AppendSet(source);
|
|
break;
|
|
case Statements.list:
|
|
long pos = FindNextWord(source, out string nextWord);
|
|
if (nextWord == "all")
|
|
{
|
|
source.Position = pos;
|
|
result = List(true);
|
|
}
|
|
else
|
|
{
|
|
result = List();
|
|
}
|
|
break;
|
|
case Statements.print:
|
|
result = Print(source, 0);
|
|
break;
|
|
case Statements.printlength:
|
|
result = Print(source, 1);
|
|
break;
|
|
case Statements.printwords:
|
|
result = Print(source, 2);
|
|
break;
|
|
case Statements.printwordcount:
|
|
result = Print(source, 3);
|
|
break;
|
|
case Statements.set:
|
|
result = AppendSet(source, false);
|
|
break;
|
|
case Statements.reverse:
|
|
result = Reverse(source);
|
|
break;
|
|
// These are additional helper functions. Thier input gets excluded from the MemoryStream
|
|
case Statements.h:
|
|
Console.WriteLine("Commands are: ");
|
|
foreach (var item in Enum.GetValues(typeof(Statements)))
|
|
{
|
|
Console.WriteLine("\t{0}", ((Statements)item).ToString());
|
|
}
|
|
// Ignore these as actual commands
|
|
source.Position = initPos;
|
|
source.SetLength(initPos);
|
|
break;
|
|
}
|
|
// Do a check semicolons etc
|
|
if (IsNextEoS(source))
|
|
{
|
|
// Increment the source pos past the semi-colon
|
|
cont = false;
|
|
source.Position++;
|
|
if (dynamicInput)
|
|
{
|
|
// Nicely format the output stream, so we may print it cleanly
|
|
source.WriteByte((byte)'\n');
|
|
}
|
|
result();
|
|
if (((Statements)statementType).Equals(Statements.exit))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else if (source.Position != lastLinePos)// - 1)
|
|
{
|
|
// In the case that we expect some more data, we must keep tabs of our current line, and keep accumulating data until we're finished
|
|
lastLinePos = source.Position;
|
|
cont = true;
|
|
source.WriteByte((byte)' ');
|
|
Console.Write(">");
|
|
}
|
|
else
|
|
{
|
|
throw new ParserException("expected a semi-colon", 0, source.Position);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new ParserException("Failed parsing statement", 0, source.Position);
|
|
}
|
|
}
|
|
// Throwing a parserexception will return us to this point immediately. From here, the line is automatically restored,
|
|
// and the excepion printed to the console window.
|
|
// This means that each function does not need to keep track of our current position in the stream
|
|
catch (ParserException e)
|
|
{
|
|
if (e.Importance > 3)
|
|
{
|
|
throw new ApplicationException("A critical error occurred.");
|
|
}
|
|
if (e.LinePosition > 0)
|
|
{
|
|
WriteDebugLine(initPos, e.LinePosition, e.Message, source);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
Console.WriteLine(e.LinePosition + ": " + e.Message);
|
|
source.Position = initPos;
|
|
source.SetLength(initPos);*/
|
|
WriteDebugLine(0, 0, e.Message, source);
|
|
}
|
|
if (!dynamicInput)
|
|
{
|
|
Environment.Exit(-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Function Handling
|
|
/// <summary>
|
|
/// Checks if the next expression in the source meets the requirements of being a key,
|
|
/// and optionally verify that key exists.
|
|
/// Also contracts the key is not reserved or constant
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="checkExist"></param>
|
|
/// <returns></returns>
|
|
private string ValidateKey(Stream source, bool checkExist)
|
|
{
|
|
long keyEndPos = FindIdentifier(source, out string key);
|
|
if (keyEndPos < 0 || key.Length == 0)
|
|
{
|
|
throw new ParserException("Could not identify object", 0, source.Position);
|
|
}
|
|
else if (checkExist && !Symbols.ContainsKey(key))
|
|
{
|
|
throw new ParserException("Key not found", 0, source.Position);
|
|
}
|
|
else if (Symbols.ContainsKey(key) && Symbols[key].Item2.HasFlag(VariableFlags.Reserved))
|
|
{
|
|
throw new ParserException("Cannot assign a value to a reserved constant", 0, keyEndPos - (key.Length + 1));
|
|
}
|
|
else
|
|
{
|
|
int indx = Array.FindIndex(key.ToCharArray(), (c) => (c > 122 || c > 90 && c < 97 && c != '_' || c > 57 && c < 65 || c < 48)); // If the overall result is good, move until one isn't
|
|
if (indx > -1)
|
|
{
|
|
throw new ParserException(string.Format("Character \'{0}\' is not valid for an identifier",key[indx]), 0, keyEndPos-key.Length + indx);
|
|
}
|
|
source.Position = keyEndPos;
|
|
}
|
|
return key;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the next expression meets the requirements of being a value
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <returns></returns>
|
|
private string ValidateValue(Stream source)
|
|
{
|
|
long valuePos = FindExpression(source, out string value);
|
|
if (valuePos < 0)
|
|
{
|
|
throw new ParserException("Could not evaluate expression", 0, source.Position);
|
|
}
|
|
else
|
|
{
|
|
source.Position = valuePos;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles the 'append x y [ + z];' case &
|
|
/// And the 'set x y [ + z];' case
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <returns>An Action that will add the key to the dictionary</returns>
|
|
Action AppendSet(Stream source, bool appendMode = true)
|
|
{
|
|
string key = ValidateKey(source, appendMode);
|
|
string value = ValidateValue(source);
|
|
if (appendMode)
|
|
{
|
|
return () => Symbols[key] = new Tuple<string, VariableFlags>(Symbols[key].Item1 + value, Symbols[key].Item2);
|
|
}
|
|
else
|
|
{
|
|
if (Symbols.ContainsKey(key))
|
|
{
|
|
return () => Symbols[key] = new Tuple<string, VariableFlags>(value, Symbols[key].Item2);
|
|
}
|
|
else
|
|
{
|
|
return () => Symbols.Add(key, new Tuple<string, VariableFlags>(value, VariableFlags.Empty));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Creates and prints a nicely formatted table of all values
|
|
/// </summary>
|
|
/// <param name="printUnprint">List values normally excluded from printing</param>
|
|
Action List(bool printUnprint = false)
|
|
{
|
|
int flagWidth = Math.Max(Enum.GetNames(typeof(VariableFlags)).Length, "Flags".Length);
|
|
int keyWidth = (int)((ConsoleWidthLimit - flagWidth) * 0.2); // 20% - flag width
|
|
int valueWidth = (int)((ConsoleWidthLimit - flagWidth) * 0.8); // 80% - flag width
|
|
|
|
StringBuilder consoleOutput = new StringBuilder();
|
|
consoleOutput.Append(string.Format("┌" + new string('─', keyWidth) + "┬" + new string('─', valueWidth) + "┬" + new string('─', flagWidth) + "┐\n"));
|
|
consoleOutput.Append(string.Format("│{0}│{1}│{2}│\n", CenterString("Symbol", keyWidth), CenterString("Value", valueWidth), CenterString("Flags", flagWidth)));
|
|
List<string> eligibleKeys = new List<string>(Symbols.Count);
|
|
foreach (var item in Symbols.Keys)
|
|
{
|
|
if (!Symbols[item].Item2.HasFlag(VariableFlags.NoPrint) || (Symbols[item].Item2.HasFlag(VariableFlags.NoPrint) && printUnprint))
|
|
{
|
|
eligibleKeys.Add(item);
|
|
}
|
|
}
|
|
if (eligibleKeys.Count > 0)
|
|
{
|
|
consoleOutput.Append(string.Format("├" + new string('─', keyWidth) + "┼" + new string('─', valueWidth) + "┼" + new string('─', flagWidth) + "┤\n"));
|
|
for (int i = 0; i < eligibleKeys.Count; i++)
|
|
{
|
|
string entryFormat = "│{0," + -1 * keyWidth + "}│{1," + -1 * valueWidth + "}│{2," + -1 * flagWidth + "}│\n";
|
|
List<string> keyLines = GetStringLines(eligibleKeys[i], keyWidth);
|
|
List<string> valueLines = GetStringLines(Symbols[eligibleKeys[i]].Item1.Replace("\r", "\\r").Replace("\n", "\\n").Replace("\t", "\\t"), valueWidth);
|
|
|
|
for (int j = 0; j < (keyLines.Count > valueLines.Count ? keyLines.Count : valueLines.Count); j++)
|
|
{
|
|
consoleOutput.Append(string.Format(entryFormat, j >= keyLines.Count ? "" : keyLines[j], j >= valueLines.Count ? "" : valueLines[j], j == 0 ? Convert.ToString((byte)Symbols[eligibleKeys[i]].Item2, 2).PadLeft(flagWidth, '0'): ""));
|
|
}
|
|
if (i + 1 < eligibleKeys.Count)
|
|
{
|
|
consoleOutput.Append(string.Format("├" + new string('─', keyWidth) + "┼" + new string('─', valueWidth) + "┼" + new string('─', flagWidth) + "┤\n"));
|
|
}
|
|
}
|
|
}
|
|
consoleOutput.Append(string.Format("└" + new string('─', keyWidth) + "┴" + new string('─', valueWidth) + "┴" + new string('─', flagWidth) + "┘\n"));
|
|
return () => Console.WriteLine(consoleOutput.ToString());
|
|
}
|
|
Action Exit(Stream source, long initialStreamLength, bool isDynamicInput=false)
|
|
{
|
|
void exitAction()
|
|
{
|
|
if (source.Length != initialStreamLength && isDynamicInput)
|
|
{
|
|
Console.WriteLine("Commands list has been modified; would you like to save it to a file?");
|
|
string commandState = "";
|
|
while (commandState.ToLower() != "y" && commandState.ToLower() != "n")
|
|
{
|
|
Console.Write("Y/n: ");
|
|
commandState = Console.ReadLine();
|
|
}
|
|
if (commandState.ToLower() == "y")
|
|
{
|
|
Console.WriteLine("Enter an output file (default {0}):", Environment.CurrentDirectory);
|
|
string path = Console.ReadLine();
|
|
if (path != "")
|
|
{
|
|
path = Path.Combine(Environment.CurrentDirectory, path);
|
|
source.Position = 0;
|
|
using (FileStream fs = File.OpenWrite(path))
|
|
{
|
|
source.CopyTo(fs);
|
|
}
|
|
source.Close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return exitAction;
|
|
}
|
|
Action Print(Stream source, int mode = 0)
|
|
{
|
|
StringBuilder outputString = new StringBuilder();
|
|
string expression = ValidateValue(source);
|
|
if (mode == 0)
|
|
{
|
|
outputString.Append(expression + Environment.NewLine);
|
|
}
|
|
else if (mode == 1)
|
|
{
|
|
outputString.Append("Length of the expression is: ");
|
|
outputString.Append(expression.Length + Environment.NewLine);
|
|
}
|
|
else if (mode >= 2)
|
|
{
|
|
|
|
string[] words = expression.Split(' ');
|
|
if (mode == 3)
|
|
{
|
|
outputString.Append("Wordcount is: ");
|
|
outputString.Append(words.Length + Environment.NewLine);
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("Words are:");
|
|
foreach (string word in words)
|
|
{
|
|
outputString.Append(word + Environment.NewLine);
|
|
}
|
|
}
|
|
}
|
|
return () => Console.WriteLine(outputString.ToString());
|
|
}
|
|
|
|
Action Reverse(Stream source)
|
|
{
|
|
string key = ValidateKey(source, true);
|
|
string ToReverse = Symbols[key].Item1;
|
|
string[] words = ToReverse.Split(' ');
|
|
StringBuilder reversed = new StringBuilder();
|
|
for (int i = words.Length - 1; i >= 0; i--)
|
|
{
|
|
reversed.Append(words[i]);
|
|
reversed.Append(' ');
|
|
}
|
|
|
|
return () => Symbols[key] = new Tuple<string, VariableFlags>(reversed.ToString(), Symbols[key].Item2);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the debug info to the screen in the form:<br/>
|
|
/// line read from stream (lineStart) to line end<br/>
|
|
/// <whitespace@caratPos> ^ <errorMessage>
|
|
/// </summary>
|
|
/// <param name="lineStart"></param>
|
|
/// <param name="caratPos"></param>
|
|
/// <param name="errorMessage"></param>
|
|
/// <param name="source"></param>
|
|
static void WriteDebugLine(long lineStart, long caratPos, string errorMessage, Stream source)
|
|
{
|
|
source.Position = lineStart;
|
|
string fullLine = GetNextLine(source);
|
|
string errorMSG = new string(' ', (caratPos - lineStart) >= 0 ? (int)(caratPos - lineStart) : 0) + "^ " + errorMessage;
|
|
Console.WriteLine(fullLine);
|
|
Console.WriteLine(errorMSG);
|
|
source.Position = lineStart;
|
|
source.SetLength(source.Position);
|
|
}
|
|
#endregion
|
|
#region Data Handling
|
|
/// <summary>
|
|
/// Parses & evaluates the expression from the stream, moving the stream to the end of the last value
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="expression"></param>
|
|
/// <returns></returns>
|
|
long FindExpression(Stream s, out string expression)
|
|
{
|
|
string result = "";
|
|
// iterate through values until we reach either the end of the stream or the end-of-statement
|
|
bool IsAppendSet = true;
|
|
while (s.Position < s.Length && !IsNextEoS(s))
|
|
{
|
|
if (IsNextEoS(s, '+'))
|
|
{
|
|
s.Position = FindNextWord(s, out _);
|
|
IsAppendSet = true;
|
|
}
|
|
else
|
|
{
|
|
long val = FindValue(s, out string value);
|
|
if (val == -1)
|
|
{
|
|
Console.WriteLine("Could not parse value");
|
|
}
|
|
if (IsAppendSet)
|
|
{
|
|
s.Position = val;
|
|
result += value;
|
|
IsAppendSet = false;
|
|
}
|
|
else
|
|
{
|
|
throw new ParserException("Append operator not set", 0, s.Position);
|
|
}
|
|
|
|
}
|
|
}
|
|
expression = result;
|
|
return s.Position;
|
|
}
|
|
/// <summary>
|
|
/// Checks ahead to see if the next non-whitespace character is the EoS indicator (';')
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="EoSChar"></param>
|
|
/// <returns>true if the next char is <paramref name="EoSChar"/>, else false</returns>
|
|
static bool IsNextEoS(Stream s, char EoSChar = ';')
|
|
{
|
|
long pos = s.Position;
|
|
char readChar = PeekChar(s);
|
|
while (readChar != 0 && char.IsWhiteSpace(readChar))
|
|
{
|
|
readChar = ReadChar(s);
|
|
}
|
|
s.Position = pos;
|
|
if (readChar == EoSChar) return true;
|
|
else return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the next value in the stream
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="returnedValue"></param>
|
|
/// <returns></returns>
|
|
long FindValue(Stream s, out string returnedValue)
|
|
{
|
|
SkipWhitespace(s);
|
|
char result = PeekChar(s);
|
|
if (result == '\"')
|
|
{
|
|
// The first char is a ", i.e. the start of a literal - search as if it were a literal.
|
|
return FindLiteral(s, out returnedValue);
|
|
}
|
|
else
|
|
{
|
|
long t = FindExistingIdentifier(s, out string keyValue);
|
|
// Set the key value to result + this read string
|
|
//keyValue = result + keyValue;
|
|
|
|
if (!Symbols.ContainsKey(keyValue))
|
|
{
|
|
throw new ParserException("Could not find key: " + keyValue, 0, s.Position);
|
|
}
|
|
returnedValue = Symbols[keyValue].Item1;
|
|
return t;
|
|
|
|
}
|
|
}
|
|
|
|
static long FindIdentifier(Stream s, out string returnedKey)
|
|
{
|
|
long wordEnd = FindNextWord(s, out returnedKey);
|
|
return wordEnd;
|
|
}
|
|
static long FindExistingIdentifier(Stream s, out string returnedKey)
|
|
{
|
|
long wordEnd = FindNextWord(s, out string identifier);
|
|
if (identifier.Length > 1 && identifier.EndsWith(';'))
|
|
{
|
|
// Remove the trailing semicolon from the parse & backtrack the identifier length one spot
|
|
identifier = identifier.TrimEnd(';');
|
|
wordEnd--;
|
|
s.Position--;
|
|
}
|
|
// Lookup the value in the symbol table
|
|
returnedKey = identifier;
|
|
return wordEnd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the end of the complete literal definition, returning the stream to the original position
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="returnedLiteral"></param>
|
|
/// <returns></returns>
|
|
static long FindLiteral(Stream s, out string returnedLiteral)
|
|
{
|
|
long pos = s.Position;
|
|
// Is a literal. Now we must parse until we find the end of the literal
|
|
// Remove the first char, if it is a literal definition.
|
|
if (PeekChar(s) == '\"') ReadChar(s);
|
|
long resultPosition = FindNextOccurance(s, (c, s) =>
|
|
{
|
|
if (c == '\"')
|
|
{
|
|
long pos = s.Position--;
|
|
if (ReadChar(s) == '\\')
|
|
{
|
|
// TODO: handle the \\ escape
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}, out string resultLiteral);
|
|
if (resultPosition > -1)
|
|
{
|
|
returnedLiteral = resultLiteral;
|
|
}
|
|
else
|
|
{
|
|
throw new ParserException("Could not parse the literal", 0, s.Position);
|
|
}
|
|
s.Position = pos;
|
|
return resultPosition;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
|
|
#region HelperFunctions
|
|
/// <summary>
|
|
/// Reads the memory stream as a UTF-8 encoded string until the next occurance of '\n' or '\r\n' (consuming, and excluded)
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <returns></returns>
|
|
static string GetNextLine(Stream s)
|
|
{
|
|
FindNextOccurance(s, '\n', out string nextLine);
|
|
return nextLine;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the end-boundary of the next word in the stream, and returns the stream to the original position
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="nextWord"></param>
|
|
/// <returns></returns>
|
|
static long FindNextWord(Stream s, out string nextWord)
|
|
{
|
|
StringBuilder newWord = new StringBuilder();
|
|
// Record our current position
|
|
long start = s.Position;
|
|
// Check if the character at the current pos is whitespace, if so, keep advancing until it isn't.
|
|
// NB: Whitespace includes carriage returns and line feeds,
|
|
// so 'set\r\n
|
|
// var
|
|
// "expression";
|
|
// should be valid
|
|
char currentChar = ReadChar(s);
|
|
while (s.Position < s.Length && char.IsWhiteSpace(currentChar))
|
|
{
|
|
currentChar = ReadChar(s);
|
|
}
|
|
// Add the last read value to the SB
|
|
newWord.Append(currentChar);
|
|
// Start a second loop, this time checking we're not a whitespace char
|
|
while (s.Position < s.Length)
|
|
{
|
|
currentChar = ReadChar(s);
|
|
if (char.IsWhiteSpace(currentChar) || currentChar == ';')
|
|
{
|
|
s.Position--;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
newWord.Append(currentChar);
|
|
}
|
|
}
|
|
nextWord = newWord.ToString();
|
|
|
|
long endPos = s.Position;
|
|
s.Position = start;
|
|
return endPos;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Finds and returns the position of the next occurance of the Func returning true.
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="p">A 'predicate'-like Func</param>
|
|
/// <param name="result">Returns the string captured while searching for the next char</param>
|
|
/// <returns></returns>
|
|
static long FindNextOccurance(Stream s, Func<char, Stream, bool> p, out string result)
|
|
{
|
|
long start = s.Position;
|
|
StringBuilder sb = new StringBuilder();
|
|
bool charFound = false;
|
|
while (s.Position < s.Length && !charFound)
|
|
{
|
|
char nextChar = ReadChar(s);
|
|
if (nextChar == 0)
|
|
{
|
|
charFound = true;
|
|
}
|
|
else if (p(nextChar, s))
|
|
{
|
|
charFound = true;
|
|
}
|
|
else
|
|
{
|
|
sb.Append(nextChar);
|
|
}
|
|
}
|
|
|
|
result = sb.ToString();
|
|
long newPosition = s.Position;
|
|
s.Position = start;
|
|
return newPosition--;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Finds the next position of the character
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <param name="c"></param>
|
|
/// <param name="result">Captures the string read in searching for the character</param>
|
|
/// <returns></returns>
|
|
static long FindNextOccurance(Stream s, char c, out string result)
|
|
{
|
|
return FindNextOccurance(s, (streamChar, s) => streamChar == c, out result);
|
|
}
|
|
/// <summary>
|
|
/// Reads the next UTF-8 encoded character in the stream, and advances the stream by the amount of characters read
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <returns></returns>
|
|
static char ReadChar(Stream s)
|
|
{
|
|
// As UTF-8 allows codepoints to span multiple bytes, reading a single byte as a character will not always give the expected
|
|
// value.
|
|
// Fortunately, the standard ASCII table is 7-bits long. The 8th bit is used to determine the character size
|
|
int readAmount = 0;
|
|
int firstChar = s.ReadByte();
|
|
if (firstChar == -1)
|
|
{
|
|
return (char)0;
|
|
}
|
|
if ((firstChar >> 3) == 0x1E) // 11110xxx implies a 4-byte length character
|
|
{
|
|
readAmount = 3;
|
|
}
|
|
else if ((firstChar >> 4) == 0xE) // 1110xxxx, 3-byte
|
|
{
|
|
readAmount = 2;
|
|
}
|
|
else if ((firstChar >> 5) == 0x6) // 110xxxxx, 2-byte
|
|
{
|
|
readAmount = 1;
|
|
}
|
|
|
|
byte[] charBytes = new byte[readAmount + 1];
|
|
charBytes[0] = (byte)firstChar;
|
|
for (int i = 1; i < readAmount; i++)
|
|
{
|
|
int nextChar = s.ReadByte();
|
|
if (nextChar >> 6 != 2) throw new Exception("Character is not a valid UTF-8 code point!");
|
|
charBytes[i] = (byte)nextChar;
|
|
}
|
|
s.Position += readAmount;
|
|
string converted = Encoding.UTF8.GetString(charBytes);
|
|
return converted[0];
|
|
}
|
|
/// <summary>
|
|
/// Reads the next character in the stream, and returns the position to the original position
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <returns></returns>
|
|
static char PeekChar(Stream s)
|
|
{
|
|
long curr = s.Position;
|
|
char c = ReadChar(s);
|
|
s.Position = curr;
|
|
return c;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the previous char
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <returns></returns>
|
|
static char PreviousChar(Stream s)
|
|
{
|
|
Stack<byte> charBytes = new Stack<byte>(4);
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (s.Position == 0)
|
|
{
|
|
break;
|
|
}
|
|
s.Position--;
|
|
byte read = (byte)s.ReadByte();
|
|
charBytes.Push(read);
|
|
// No longer an UTF-8 extension, last byte is the final
|
|
if (read >> 6 != 2) break;
|
|
}
|
|
string converted = Encoding.UTF8.GetString(charBytes.ToArray());
|
|
return converted[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Skips whitespace characters
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
static void SkipWhitespace(Stream s)
|
|
{
|
|
char c = PeekChar(s);
|
|
while (s.Position < s.Length && char.IsWhiteSpace(c))
|
|
{
|
|
ReadChar(s); // move by the size of that character
|
|
c = PeekChar(s);
|
|
}
|
|
}
|
|
|
|
static string CenterString(string source, int totalPadding, char paddingChar = ' ')
|
|
{
|
|
if (source.Length >= totalPadding) return source;
|
|
int rightHalf = (int)Math.Ceiling(source.Length / 2.0);
|
|
int leftHalfPad = (int)Math.Floor(totalPadding / 2.0);
|
|
int rightHalfPad = (int)Math.Ceiling(totalPadding / 2.0);
|
|
string t = "{0," + leftHalfPad + "}{1," + -1 * rightHalfPad + "}";
|
|
string result = string.Format(t, source[..rightHalf], source[rightHalf..]);
|
|
return result;
|
|
}
|
|
|
|
static List<string> GetStringLines(string source, int maxWidth)
|
|
{
|
|
List<string> lines = new List<string>();
|
|
int j = 0;
|
|
while (j < source.Length)
|
|
{
|
|
int max = j + maxWidth <= source.Length ? j + maxWidth : source.Length;
|
|
lines.Add(source[j..max]);
|
|
j = max;
|
|
}
|
|
return lines;
|
|
}
|
|
#endregion
|
|
public class ParserException : Exception
|
|
{
|
|
/// <summary>
|
|
/// Importance is used to signify how the parser should respond to the error.
|
|
/// A code of 3 or greater is a critical error; the application will throw the error further up the call and exit.
|
|
/// 0 implies the line may be retried.
|
|
/// 1 should imply the current block is not valid and should be retried.
|
|
/// </summary>
|
|
public int Importance = 0;
|
|
public long LinePosition = -1;
|
|
public ParserException(string message, int importance, long linePos) : base(message)
|
|
{
|
|
Importance = importance;
|
|
LinePosition = linePos;
|
|
}
|
|
}
|
|
}
|
|
}
|