private static Token ContinueReadingNakedStringToken(StringCodeReader charStream, char firstChar, bool forgive)
{
var sb = new StringBuilder();
sb.Append(firstChar);
char ch;
while (true)
{
var chVal = charStream.Read();
if (chVal < 0)
{
var e = new UnexpectedCharacterException(
charStream.LineNo, charStream.Col, "continuation of naked string (or decimal)", (char)0);
PardonOrDeath(e, forgive);
return(FailureToken);
}
ch = (char)chVal;
if (char.IsWhiteSpace((ch)))
{
break;
}
sb.Append(ch);
}
return(new Token(TokenType.NakedString, sb.ToString()));
}
private static Token ContinueReadingComment(StringCodeReader charStream, bool forgive)
{
char ch;
if ((ch = (char)charStream.Read()) != '/')
{
var e = new UnexpectedCharacterException(charStream.LineNo, charStream.Col - 1, "beginning of any token", ch);
PardonOrDeath(e, forgive);
return(FailureToken);
}
var sb = new StringBuilder();
while (true)
{
var chVal = charStream.Read();
if (chVal < 0)
{
var e = new UnexpectedCharacterException(
charStream.LineNo, charStream.Col, "continuation of comment", (char)0);
PardonOrDeath(e, forgive);
return(FailureToken);
}
ch = (char)chVal;
if (IsLineSeparator(ch))
{
break;
}
sb.Append(ch);
}
return(new Token(TokenType.Comment, sb.ToString()));
}
public void GroupTest7()
{
Parser parser = new Parser("Group { .Key1 Value1 .Key2 }");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('}', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(28, exception.Column);
}
public void ConstructorTest8()
{
Parser parser = new Parser(" ( X Y ) ");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('(', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(2, exception.Column);
}
public void GroupTest13()
{
Parser parser = new Parser("Group { }Text");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('T', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(10, exception.Column);
}
public void GroupTest12()
{
Parser parser = new Parser("Text [Hello world] { }");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('{', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(20, exception.Column);
}
public void GroupTest11()
{
Parser parser = new Parser("[ Group (Hello world] { } )");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal(']', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(21, exception.Column);
}
public void NumberTest38()
{
Parser parser = new Parser("6.67E-11X");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('X', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(9, exception.Column);
}
public void NullTest2()
{
Parser parser = new Parser("@nil");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('i', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(3, exception.Column);
}
public void ArrayTest6()
{
Parser parser = new Parser("Text [1 2 3) { }");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal(')', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(12, exception.Column);
}
public void ArrayTest9()
{
Parser parser = new Parser("[1 2 3]Test");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('T', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(8, exception.Column);
}
public void SimpleTest5()
{
Parser parser = new Parser("ASDML\"asdml");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('"', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(6, exception.Column);
}
public void ArrayTest11()
{
Parser parser = new Parser("[[1 2 3][4 5 6]]");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('[', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(9, exception.Column);
}
public void EscapeTest3()
{
Parser parser = new Parser("\"___\\____\"");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('_', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(6, exception.Column);
}
public void SimpleTest2()
{
Parser parser = new Parser("x42@+.#-");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('@', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(4, exception.Column);
}
public void TextTest13()
{
Parser parser = new Parser("\"This is a\"text");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('t', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(12, exception.Column);
}
private static int Run(Options options)
{
try
{
using (StreamReader sr = new StreamReader(File.OpenRead(options.File)))
{
StreamLexer parser = new StreamLexer(sr, options.Verbose, options.Debug, options.MultiError);
Program prog = parser.Parse();
prog.Run();
}
}
catch (Exception ex)
{
switch (ex)
{
case InvalidSyntaxException exception:
InvalidSyntaxException ise = exception;
OutputEx(ise.Message, ise.Line, ise.Position, options.File);
break;
case AssertionException exception:
AssertionException ae = exception;
OutputEx(ae.Message, ae.Line, ae.Position, options.File);
break;
case MplDivideByZeroException exception:
MplDivideByZeroException mdbze = exception;
OutputEx(mdbze.Message, mdbze.Line, mdbze.Position, options.File);
break;
case RuntimeException exception:
RuntimeException rte = exception;
OutputEx(rte.Message, rte.Line, rte.Position, options.File);
break;
case UnexpectedCharacterException exception:
UnexpectedCharacterException uece = exception;
OutputEx(uece.Message, uece.Line, uece.Position, options.File);
break;
case UnsupportedCharacterException exception:
UnsupportedCharacterException usce = exception;
OutputEx(usce.Message, usce.Line, usce.Position, options.File);
break;
case MultiException exception:
MultiException me = exception;
OutputMultiEx(me, options.File);
break;
default:
throw;
}
}
return(0);
}
public void GroupTest10()
{
Parser parser = new Parser("Group1 (Hello world) Group2 { }");
UnexpectedCharacterException exception = Assert.Throws <UnexpectedCharacterException>(parser.Parse);
Assert.Equal('G', exception.Character);
Assert.Equal(1, exception.Line);
Assert.Equal(22, exception.Column);
}
private static Token ContinueReadingStringToken(StringCodeReader charStream, bool forgive)
{
var escaping = false;
var openedQuote = false;
var sb = new StringBuilder();
while (true)
{
var chVal = charStream.Read();
if (chVal < 0)
{
var e = new UnexpectedCharacterException(
charStream.LineNo, charStream.Col, "continuation of string literal", (char)0);
PardonOrDeath(e, forgive);
return(FailureToken);
}
var ch = (char)chVal;
if (escaping)
{
ReadEscapedChar(ch, sb);
escaping = false;
}
else if (ch == '"')
{
if (openedQuote)
{
sb.Append('"');
openedQuote = false;
}
else
{
var chPeek = (char)charStream.Peek();
if (char.IsWhiteSpace(chPeek))
{
return(new Token(TokenType.StringType, sb.ToString()));
}
else
{
openedQuote = true;
sb.Append('"');
}
}
}
else if (ch == '\\')
{
escaping = true;
}
else
{
sb.Append(ch);
}
}
}
private static void OutputMultiEx(MultiException me, string filePath)
{
Console.Write("-----------------------------------\n");
Console.Write($"Encountered {me.Exceptions.Count} exceptions during parsing:\n");
foreach (Exception ex in me.Exceptions)
{
switch (ex)
{
case InvalidSyntaxException exception:
InvalidSyntaxException ise = exception;
OutputEx(ise.Message, ise.Line, ise.Position, filePath);
break;
case AssertionException exception:
AssertionException ae = exception;
OutputEx(ae.Message, ae.Line, ae.Position, filePath);
break;
case MplDivideByZeroException exception:
MplDivideByZeroException mdbze = exception;
OutputEx(mdbze.Message, mdbze.Line, mdbze.Position, filePath);
break;
case RuntimeException exception:
RuntimeException rte = exception;
OutputEx(rte.Message, rte.Line, rte.Position, filePath);
break;
case UnexpectedCharacterException exception:
UnexpectedCharacterException uece = exception;
OutputEx(uece.Message, uece.Line, uece.Position, filePath);
break;
case UnsupportedCharacterException exception:
UnsupportedCharacterException usce = exception;
OutputEx(usce.Message, usce.Line, usce.Position, filePath);
break;
default:
throw ex;
}
}
}
public static Token NextToken(StringCodeReader charStream, bool forgive)
{
// Assuming no emoji.
// May need this later?
// https://stackoverflow.com/questions/32895131/how-to-compare-and-convert-emoji-characters-in-c-sharp
char ch;
do
{
var chVal = charStream.Read();
if (chVal < 0)
{
return(EofToken);
}
ch = (char)chVal;
} while (char.IsWhiteSpace(ch));
switch (ch)
{
case '{': return(LstBeginToken);
case '}': return(LstEndToken);
case '"': return(ContinueReadingStringToken(charStream, forgive));
case '/': return(ContinueReadingComment(charStream, forgive));
default:
if (char.IsLetterOrDigit(ch))
{
return(ContinueReadingNakedStringToken(charStream, ch, forgive));
}
var e = new UnexpectedCharacterException(
charStream.LineNo, charStream.Col, "beginning of any token", ch);
PardonOrDeath(e, forgive);
return(FailureToken);
}
}
