private static object ReadTagged(PushbackTextReader r, Symbol tag, IPersistentMap opts)
{
object o = ReadAux(r, opts);
ILookup readers = (ILookup)RT.get(opts, READERS);
IFn dataReader = (IFn)RT.get(readers, tag);
if (dataReader == null)
{
dataReader = (IFn)RT.get(RT.DefaultDataReadersVar.deref(), tag);
}
if (dataReader == null)
{
IFn defaultReader = (IFn)RT.get(opts, DEFAULT);
if (defaultReader != null)
{
return(defaultReader.invoke(tag, o));
}
else
{
throw new InvalidOperationException("No reader function for tag " + tag.ToString());
}
}
else
{
return(dataReader.invoke(o));
}
}
static int readUnicodeChar(PushbackTextReader r, int initch, int radix, int length, bool exact)
{
int uc = CharValueInRadix(initch, radix);
if (uc == -1)
{
throw new ArgumentException("Invalid digit: " + (char)initch);
}
int i = 1;
for (; i < length; ++i)
{
int ch = r.Read();
if (ch == -1 || isWhitespace(ch) || isMacro(ch))
{
Unread(r, ch);
break;
}
int d = CharValueInRadix(ch, radix);
if (d == -1)
{
throw new ArgumentException("Invalid digit: " + (char)ch);
}
uc = uc * radix + d;
}
if (i != length && exact)
{
throw new ArgumentException("Invalid character length: " + i + ", should be: " + length);
}
return(uc);
}
public object LoadFromStream(PushbackTextReader rdr, bool addPrint)
{
object ret = null;
object eofVal = new object();
object form;
while ((form = LispReader.read(rdr, false, eofVal, false)) != eofVal)
{
try
{
//LambdaExpression ast = Compiler.GenerateLambda(form, addPrint);
//ret = ast.Compile().DynamicInvoke();
ret = Compiler.eval(form);
RT.print(ret, Console.Out);
}
catch (Exception ex)
{
if (addPrint)
{
Exception root = ex;
while (root.InnerException != null)
{
root = root.InnerException;
}
Console.WriteLine("Error evaluating {0}: {1}", form, root.Message);
Console.WriteLine(root.StackTrace);
}
}
}
return(ret);
}
static object readNumber(PushbackTextReader r, char initch)
{
StringBuilder sb = new StringBuilder();
sb.Append(initch);
for (;;)
{
int ch = r.Read();
if (ch == -1 || isWhitespace(ch) || isMacro(ch))
{
Unread(r, ch);
break;
}
sb.Append((char)ch);
}
string s = sb.ToString();
object n = MatchNumber(s);
if (n == null)
{
throw new FormatException("Invalid number: " + s);
}
return(n);
}
private static async Task <T> ReadValue <T>(
PushbackTextReader reader,
CancellationToken cancellationToken)
{
var startChar = (Char)reader.Read();
if (startChar < 0)
{
throw new InvalidDataException("Unexpected end of buffer attempting to read Troop message.");
}
else if (startChar != '<')
{
throw new InvalidDataException($"Expected a value string with '<value>' but found a starting character of: '{startChar}'");
}
using var jsonReader = new MessageJsonReader(reader);
var token = await JToken.LoadAsync(jsonReader, cancellationToken);
// Hopefully this works with value types
var result = token.ToObject <T>();
// Calling close pushes unused buffer back to the reader
jsonReader.Close();
var endChar = (Char)reader.Read();
if (endChar != '>')
{
throw new InvalidDataException($"Expected a value string with '<value>' but found a ending character of: '{startChar}'");
}
return(result);
}
static void Unread(PushbackTextReader r, int ch)
{
if (ch != -1)
{
r.Unread(ch);
}
}
public static Input ReadArguments(string[] args)
{
var input = new Input();
input.options = PersistentHashMap.EMPTY;
input.functions = PersistentVector.EMPTY;
var argString = string.Join(" ", args);
var pbtr = new PushbackTextReader(new StringReader(argString));
for (;;)
{
try
{
var o = ArgumentReader.read(pbtr, true, null, false, null);
if (o is Keyword)
{
var val = ArgumentReader.read(pbtr, true, null, false, null);
input.options = input.options.assoc(o, val);
}
else if (o is Symbol)
{
input.functions = (PersistentVector)input.functions.cons(o);
}
}
catch (EndOfStreamException)
{
return(input);
}
}
}
protected override object Read(PushbackTextReader r, char leftbrace, object opts)
{
Object[] a = ReadDelimitedList('}', r, true, opts).ToArray();
if ((a.Length & 1) == 1)
{
throw new ArgumentException("Map literal must contain an even number of forms");
}
return(RT.map(a));
}
static List <Object> ReadDelimitedList(char delim, PushbackTextReader r, bool isRecursive, object opts)
{
LineNumberingTextReader lntr = r as LineNumberingTextReader;
int firstLine = lntr != null ? lntr.LineNumber : -1;
List <Object> a = new List <object>();
for (;;)
{
int ch = r.Read();
while (isWhitespace(ch))
{
ch = r.Read();
}
if (ch == -1)
{
if (firstLine < 0)
{
throw new EndOfStreamException("EOF while reading");
}
else
{
throw new EndOfStreamException("EOF while reading, starting at line " + firstLine);
}
}
if (ch == delim)
{
break;
}
IFn macroFn = getMacro(ch);
if (macroFn != null)
{
Object mret = macroFn.invoke(r, (char)ch, opts);
//no op macros return the reader
if (mret != r)
{
a.Add(mret);
}
}
else
{
Unread(r, ch);
object o = read(r, true, null, isRecursive, opts);
if (o != r)
{
a.Add(o);
}
}
}
return(a);
}
protected override object Read(PushbackTextReader r, char semicolon, object opts)
{
int ch;
do
{
ch = r.Read();
} while (ch != -1 && ch != '\n' && ch != '\r');
return(r);
}
protected override object Read(PushbackTextReader r, char leftparen, object opts)
{
object name = read(r, true, null, false, opts);
Symbol sym = name as Symbol;
if (sym == null)
{
throw new InvalidOperationException("Reader tag must be a symbol");
}
return(ReadTagged(r, sym, (IPersistentMap)opts));
}
private async Task ReceiveLoop(CancellationToken cancellationToken)
{
using var textReader = new StreamReader(this.stream, messageEncoding);
using var pushbackReader = new PushbackTextReader(textReader);
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
MessageBase message;
try {
message = await TaskExtensions.WhenAny(
MessageBase.ReadMessage(pushbackReader, cancellationToken),
Task.Delay(TimeSpan.FromSeconds(ReceiveTimeoutSeconds), cancellationToken)
.Then(() => (MessageBase)null)
);
} catch (JsonReaderException ex) {
Console.WriteLine(
$"Error reading message, aborting receive loop: {ex.Message}"
);
this.Shutdown();
return;
}
if (message == null)
{
Console.WriteLine("Receive Timeout!");
// a timeout occurred!
this.Shutdown();
return;
}
var hubClient = this.hubContext.Clients.Client(this.hubConnectionId);
if (hubClient == null)
{
Console.WriteLine("Browser Disconnected!");
// Our client disconnected!
this.Shutdown();
return;
}
Console.WriteLine($"Message received: {message}");
await hubClient.ReceiveMessage(message, cancellationToken);
}
}
public static ISeq ReadArguments(string[] args)
{
var list = PersistentVector.EMPTY; //PersistentList.EmptyList(null);
var argString = string.Join(" ", args);
var pbtr = new PushbackTextReader(new StringReader(argString));
for (;;)
{
try
{
list = (PersistentVector)list.cons(ArgumentReader.read(pbtr, true, null, false, null));
}
catch (EndOfStreamException)
{
return(list.seq());
}
}
}
internal object ParseFile()
{
IPersistentVector pv = PersistentVector.EMPTY;
StringReader sr = new StringReader(_text);
PushbackTextReader pr = new PushbackTextReader(sr);
pv = pv.cons(Compiler.DO);
object eofVal = new object();
object form;
while ((form = LispReader.read(pr, false, eofVal, false)) != eofVal)
{
pv = pv.cons(form);
}
return(pv.seq());
}
protected override object Read(PushbackTextReader r, char leftparen, object opts)
{
//int startLine = -1;
//int startCol = -1;
//LineNumberingTextReader lntr = r as LineNumberingTextReader;
//if (lntr != null)
//{
// startLine = lntr.LineNumber;
// startCol = lntr.ColumnNumber;
//}
IList <Object> list = ReadDelimitedList(')', r, true, opts);
if (list.Count == 0)
{
return(PersistentList.EMPTY);
}
IObj s = (IObj)PersistentList.create((IList)list);
return(s);
}
protected override object Read(PushbackTextReader r, char hash, object opts)
{
int ch = r.Read();
if (ch == -1)
{
throw new EndOfStreamException("EOF while reading character");
}
IFn fn = _dispatchMacros[ch];
if (fn == null)
{
// try tagged reader
if (Char.IsLetter((char)ch))
{
Unread(r, ch);
return(_taggedReader.invoke(r, (char)ch, opts));
}
throw new InvalidOperationException(String.Format("No dispatch macro for: {0}", (char)ch));
}
return(fn.invoke(r, (char)ch, opts));
}
static string readSimpleToken(PushbackTextReader r, char initch, bool leadConstituent)
{
if (leadConstituent && NonConstituent(initch))
{
throw new InvalidOperationException("Invalid leading characters: " + (char)initch);
}
StringBuilder sb = new StringBuilder();
sb.Append(initch);
for (;;)
{
int ch = r.Read();
if (ch == -1 || isWhitespace(ch) || isTerminatingMacro(ch))
{
Unread(r, ch);
return(sb.ToString());
}
sb.Append((char)ch);
}
}
public static object read(PushbackTextReader r,
bool eofIsError,
object eofValue,
bool isRecursive,
Object opts)
{
try
{
for (;;)
{
int ch = r.Read();
while (isWhitespace(ch))
{
ch = r.Read();
}
if (ch == -1)
{
if (eofIsError)
{
throw new EndOfStreamException("EOF while reading");
}
return(eofValue);
}
if (Char.IsDigit((char)ch))
{
object n = readNumber(r, (char)ch);
return(RT.suppressRead() ? null : n);
}
IFn macroFn = getMacro(ch);
if (macroFn != null)
{
object ret = macroFn.invoke(r, (char)ch, opts);
if (RT.suppressRead())
{
return(null);
}
// no op macros return the reader
if (ret == r)
{
continue;
}
return(ret);
}
if (ch == '+' || ch == '-')
{
int ch2 = r.Read();
if (Char.IsDigit((char)ch2))
{
Unread(r, ch2);
object n = readNumber(r, (char)ch);
return(RT.suppressRead() ? null : n);
}
Unread(r, ch2);
}
//string token = readToken(r, (char)ch);
//return RT.suppressRead() ? null : interpretToken(token);
string rawToken;
string token;
string mask;
bool eofSeen;
readToken(r, (char)ch, true, out rawToken, out token, out mask, out eofSeen);
if (eofSeen)
{
if (eofIsError)
{
throw new EndOfStreamException("EOF while reading symbol");
}
return(eofValue);
}
return(RT.suppressRead() ? null : InterpretToken(rawToken, token, mask));
}
}
catch (Exception e)
{
if (isRecursive)
{
throw;
}
LineNumberingTextReader lntr = r as LineNumberingTextReader;
if (lntr == null)
{
throw;
}
throw new ReaderException(lntr.LineNumber, lntr.ColumnNumber, e);
}
}
protected override object Read(PushbackTextReader r, char caret, object opts)
{
int startLine = -1;
int startCol = -1;
LineNumberingTextReader lntr = r as LineNumberingTextReader;
if (lntr != null)
{
startLine = lntr.LineNumber;
startCol = lntr.ColumnNumber;
}
IPersistentMap metaAsMap;
{
object meta = ReadAux(r, opts);
if (meta is Symbol || meta is String)
{
metaAsMap = RT.map(RT.TagKey, meta);
}
else if (meta is Keyword)
{
metaAsMap = RT.map(meta, true);
}
else if ((metaAsMap = meta as IPersistentMap) == null)
{
throw new ArgumentException("Metadata must be Symbol,Keyword,String or Map");
}
}
object o = ReadAux(r, opts);
if (o is IMeta)
{
if (startLine != -1 && o is ISeq)
{
metaAsMap = metaAsMap.assoc(RT.LineKey, startLine)
.assoc(RT.ColumnKey, startCol)
.assoc(RT.SourceSpanKey, RT.map(
RT.StartLineKey, startLine,
RT.StartColumnKey, startCol,
RT.EndLineKey, lntr.LineNumber,
RT.EndColumnKey, lntr.ColumnNumber));
}
IReference iref = o as IReference;
if (iref != null)
{
iref.resetMeta(metaAsMap);
return(o);
}
object ometa = RT.meta(o);
for (ISeq s = RT.seq(metaAsMap); s != null; s = s.next())
{
IMapEntry kv = (IMapEntry)s.first();
ometa = RT.assoc(ometa, kv.key(), kv.val());
}
return(((IObj)o).withMeta((IPersistentMap)ometa));
}
else
{
throw new ArgumentException("Metadata can only be applied to IMetas");
}
}
public static Object read(PushbackTextReader r, IPersistentMap opts)
{
return(read(r, !opts.containsKey(EOF), opts.valAt(EOF), false, opts));
}
protected override object Read(PushbackTextReader r, char underscore, object opts)
{
ReadAux(r, opts);
return(r);
}
protected override object Read(PushbackTextReader reader, char leftangle, object opts)
{
throw new ArgumentException("Unreadable form");
}
static public Object readString(String s, IPersistentMap opts)
{
PushbackTextReader r = new PushbackTextReader(new System.IO.StringReader(s));
return(read(r, opts));
}
protected override object Read(PushbackTextReader r, char doublequote, object opts)
{
StringBuilder sb = new StringBuilder();
for (int ch = r.Read(); ch != '"'; ch = r.Read())
{
if (ch == -1)
{
throw new EndOfStreamException("EOF while reading string");
}
if (ch == '\\') //escape
{
ch = r.Read();
if (ch == -1)
{
throw new EndOfStreamException("EOF while reading string");
}
switch (ch)
{
case 't':
ch = '\t';
break;
case 'r':
ch = '\r';
break;
case 'n':
ch = '\n';
break;
case '\\':
break;
case '"':
break;
case 'b':
ch = '\b';
break;
case 'f':
ch = '\f';
break;
case 'u':
ch = r.Read();
if (CharValueInRadix(ch, 16) == -1)
{
throw new InvalidOperationException("Invalid unicode escape: \\u" + (char)ch);
}
ch = readUnicodeChar((PushbackTextReader)r, ch, 16, 4, true);
break;
default:
{
//if (CharValueInRadix(ch, 8) != -1) -- this is correct, but we end up with different error message for 8,9 than JVM, so do the following to match:
if (Char.IsDigit((char)ch))
{
ch = readUnicodeChar((PushbackTextReader)r, ch, 8, 3, false);
if (ch > 255) //octal377
{
throw new InvalidOperationException("Octal escape sequence must be in range [0, 377].");
}
}
else
{
throw new InvalidOperationException("Unsupported escape character: \\" + (char)ch);
}
}
break;
}
}
sb.Append((char)ch);
}
return(sb.ToString());
}
protected override object Read(PushbackTextReader r, char backslash, object opts)
{
int ch = r.Read();
if (ch == -1)
{
throw new EndOfStreamException("EOF while reading character");
}
String token = readSimpleToken(r, (char)ch, false);
if (token.Length == 1)
{
return(token[0]);
}
else if (token.Equals("newline"))
{
return('\n');
}
else if (token.Equals("space"))
{
return(' ');
}
else if (token.Equals("tab"))
{
return('\t');
}
else if (token.Equals("backspace"))
{
return('\b');
}
else if (token.Equals("formfeed"))
{
return('\f');
}
else if (token.Equals("return"))
{
return('\r');
}
else if (token.StartsWith("u"))
{
char c = (char)readUnicodeChar(token, 1, 4, 16);
if (c >= '\uD800' && c <= '\uDFFF') // surrogate code unit?
{
throw new InvalidOperationException("Invalid character constant: \\u" + ((int)c).ToString("x"));
}
return(c);
}
else if (token.StartsWith("o"))
{
int len = token.Length - 1;
if (len > 3)
{
throw new InvalidOperationException("Invalid octal escape sequence length: " + len);
}
int uc = readUnicodeChar(token, 1, len, 8);
if (uc > 255) //octal377
{
throw new InvalidOperationException("Octal escape sequence must be in range [0, 377].");
}
return((char)uc);
}
throw new InvalidOperationException("Unsupported character: \\" + token);
}
protected abstract object Read(PushbackTextReader r, char c, object opts);
protected override object Read(PushbackTextReader reader, char rightdelim, object opts)
{
throw new ArgumentException("Unmatched delimiter: " + rightdelim);
}
protected override object Read(PushbackTextReader r, char leftbracket, object opts)
{
return(PersistentHashSet.createWithCheck(ReadDelimitedList('}', r, true, opts)));
}
static void readToken(PushbackTextReader r, char initch, bool leadConstituent, out String rawToken, out String token, out String mask, out bool eofSeen)
{
if (leadConstituent && NonConstituent(initch))
{
throw new InvalidOperationException("Invalid leading characters: " + (char)initch);
}
bool allowSymEscape = RT.booleanCast(RT.AllowSymbolEscapeVar.deref());
bool rawMode = false;
StringBuilder sbRaw = new StringBuilder();
StringBuilder sbToken = new StringBuilder();
StringBuilder sbMask = new StringBuilder();
if (allowSymEscape && initch == '|')
{
rawMode = true;
sbRaw.Append(initch);
}
else
{
sbRaw.Append(initch);
sbToken.Append(initch);
sbMask.Append(initch);
}
for (;;)
{
int ch = r.Read();
if (rawMode)
{
if (ch == -1)
{
rawToken = sbRaw.ToString();
token = sbToken.ToString();
mask = sbMask.ToString();
eofSeen = true;
return;
}
if (ch == '|')
{
int ch2 = r.Read();
if (ch2 == '|')
{
sbRaw.Append('|');
sbToken.Append('|');
sbMask.Append('a');
}
else
{
r.Unread(ch2);
rawMode = false;
sbRaw.Append(ch);
}
}
else
{
sbRaw.Append((char)ch);
sbToken.Append((char)ch);
sbMask.Append('a');
}
}
else
{
if (ch == -1 || isWhitespace(ch) || isTerminatingMacro(ch))
{
Unread(r, ch);
rawToken = sbRaw.ToString();
token = sbToken.ToString();
mask = sbMask.ToString();
eofSeen = false;
return;
}
else if (NonConstituent(ch))
{
throw new InvalidOperationException("Invalid constituent character: " + (char)ch);
}
else if (ch == '|' && allowSymEscape)
{
rawMode = true;
sbRaw.Append((char)ch);
}
else
{
sbRaw.Append((char)ch);
sbToken.Append((char)ch);
sbMask.Append((char)ch);
}
}
}
}
private static object ReadAux(PushbackTextReader r, object opts)
{
return(read(r, true, null, true, opts));
}
