public ContractEnforcer(Object obj, string message)
{
this.obj = obj;
if (Runtime.IsPrefixed(message, out type, out name))
{
isSetter = type == "set";
}
else
{
type = "";
name = message;
isSetter = false;
}
OldValue = new Nil();
switch (type)
{
case "get":
case "set":
disabled = false;
break;
default:
disabled = true;
break;
}
}
public override Element BuildElement(Element element)
{
if (!(element is BlockContainer))
{
return(element);
}
var newSubs = Nil.L <Element>();
foreach (Element el in element.Subs)
{
if (el is Paragraph p && p.Subs.Any(_ => _ is LineBreak))
{
var lineSubs = Nil.L <Element>();
p.Subs.GroupAdjacent(_ => _ is LineBreak).Where(_ => !_.Key).ForEach(_ => {
lineSubs.Add(new Paragraph {
Subs = _.ToList()
});
});
if (lineSubs.Any())
{
p.MoveAttributesTo(lineSubs.First());
}
newSubs = newSubs.Concat(lineSubs).ToList();
}
public Parser(Scanner s)
{
scanner = s;
nil = new Nil();
tr = new BoolLit(true);
fa = new BoolLit(false);
}
public string Get(string key)
{
lock (SyncLock(key))
{
string result;
var exists = _databaseImpl.Exists(key);
if (!exists)
{
result = new Nil();
}
else
{
var valueInternal = _databaseImpl.Get <object>(key);
if (!(valueInternal is string value))
{
throw new InMemoryDatabaseOperationException(key, $"WRONGTYPE Operation against a key holding the wrong kind of value");
}
result = value;
}
return(result);
}
}
//-------------------------------------------------
#region Overrided Methods Region
/// <summary>
/// Warning: Don't use this function for saving this object to the server,
/// this is just for showing this object in the Design of the Game.
/// If you want to save this to the server, use this: <see cref="GetForServer()"/>!
/// </summary>
/// <returns></returns>
public override string ToString()
{
if (IsNegative)
{
return("-" + (-this));
}
if (Bil == 0)
{
if (Mil == 0)
{
if (Kil == 0)
{
return(Nil.ToString());
}
else
{
return(Kil.ToString() + " K");
}
}
else
{
return(Mil.ToString() + " M");
}
}
else
{
return(Bil.ToString() + " B");
}
}
public override void SetVariable(string name, Value value)
{
var invariant = invariants[name];
if (invariant == null)
{
base.SetVariable(name, value);
return;
}
Value oldValue = new Nil();
if (variables.ContainsKey(name))
{
oldValue = variables[name];
}
base.SetVariable(name, value);
var arguments = new Arguments();
arguments.AddArgument(oldValue);
arguments.AddArgument(value);
var result = obj.Invoke(invariant, arguments);
result.IsTrue.Must().BeTrue().OrThrow(LOCATION, () => $"Invariant failed for {name}");
}
public StrongString GetForServer()
{
return(Bil.ToString() + CharSeparater +
Mil.ToString() + CharSeparater +
Kil.ToString() + CharSeparater +
Nil.ToString() + CharSeparater);
}
public string Zrank(string key, string member)
{
lock (SyncLock(key))
{
string result;
var exists = _databaseImpl.Exists(key);
if (!exists)
{
result = new Nil();
}
else
{
var valueInternal = _databaseImpl.Get <object>(key);
if (!(valueInternal is SortedSet sortedSet))
{
throw new InMemoryDatabaseOperationException(key, $"WRONGTYPE Operation against a key holding the wrong kind of value");
}
var rank = sortedSet.Rank(member);
if (!rank.HasValue)
{
result = new Nil();
}
else
{
result = rank.Value.ToString();
}
}
return(result);
}
}
public void Print_Nil()
{
const string expected = "nil";
var input = new Nil();
var actual = Printer.Print(input);
Assert.Equal(expected, actual);
}
public Nil ReadNil()
{
Nil value = MessagePackBinary.ReadNil(Buffer, Position, out int readSize);
Position += readSize;
return(value);
}
public static void Main()
{
var vec1 = new Cons <Z, int>(4, new Nil <int>());
Console.WriteLine(vec1.First()); // 4
var vec0 = new Nil <int>();
Console.WriteLine(vec0.First()); // type error!
}
public bool Visit(Nil node)
{
if (node.SymType != null)
{
return(true);
}
node.IsLValue = false;
node.SymType = SymbolStack.SymNil;
return(true);
}
public StrongString GetForServer()
{
var _s = CharSeparater;
_s +=
(IsNegative ? NegetiveSerialized :
PossitiveSerialized) +
Bil.ToString() + CharSeparater +
Mil.ToString() + CharSeparater +
Kil.ToString() + CharSeparater +
Nil.ToString() + CharSeparater;;
return(_s);
}
public override Element BuildElement(Element element)
{
if (element is BlockContainer &&
element.Subs.Any(_ => _ is Listing l && l.Kind.IsOneOf(ListingKind.Items, ListingKind.CheckItems)))
{
var newSubs = Nil.L <Element>();
element.Subs.ForEach(_ => {
if (_ is Listing list && list.Kind.IsOneOf(ListingKind.Items, ListingKind.CheckItems))
{
list.Subs.ForEach(item => {
newSubs.Add(new Item(item, list.Kind));
});
}
//parses grammar for exp ->
public Node parseExp()
{
Token tok;
tok = scanner.getNextToken();
//checks for end of file
if (tok == null)
{
Nil retNil = nilPoint;
return(retNil);
}
//checks for case of left parenthesis
if (tok.getType() == TokenType.LPAREN)
{
return(parseRest(true));
}
//checks for case of false constant
else if (tok.getType() == TokenType.FALSE)
{
BoolLit ret = fBool;
return(ret);
}
//checks for case of true constant
else if (tok.getType() == TokenType.TRUE)
{
BoolLit ret = tBool;
return(ret);
}
//checks for case of QUOTE symbol
else if (tok.getType() == TokenType.QUOTE)
{
return(new Cons(new Ident("quote"), new Cons(parseExp(), new Nil()), true));
}
//checks for case int constant
else if (tok.getType() == TokenType.INT)
{
return(new IntLit(tok.getIntVal()));
}
//checks for case of string constant
else if (tok.getType() == TokenType.STRING)
{
return(new StringLit(tok.getStringVal()));
}
//checks for case of identifier
else if (tok.getType() == TokenType.IDENT)
{
return(new Ident(tok.getName()));
}
return(null);
}
private static object Mplus(object d1, object d2)
{
if (Nil.Equals(d1))
{
return(d2);
}
else if (IsProcedure(d1))
{
return(new Func <object>(() => Mplus(d2, Call(d1))));
}
else
{
return(Cons(Car(d1), Mplus(Cdr(d1), d2)));
}
}
public static object Bind(object d, Func <object, object> g)
{
if (Nil.Equals(d))
{
return(Mzero);
}
else if (IsProcedure(d))
{
return(new Func <object>(() => Bind(Call(d), g)));
}
else
{
return(Mplus(g.Call(Car(d)), Bind(Cdr(d), g)));
}
}
//method for parsing rest-> grammar
protected Node parseRest(bool startsList)
{
Token tok;
tok = scanner.getNextToken();
if (tok.getType() == TokenType.RPAREN)
{
Nil retNil = nilPoint;
return(retNil);
}
else
{
return(new Cons(parseExp(tok), parseRest(false), startsList));
}
return(null);
}
public static string Print(IValue expression)
{
return(expression switch
{
Boolean boolean => boolean.Value ? "#t" : "#f",
Integer integer => integer.Value.ToString(),
Float floating => AddDotZeroIfInteger(floating.Value.ToString("G7",
CultureInfo.InvariantCulture.NumberFormat)),
Nil _ => "nil",
String @string => $"\"{@string.Value}\"",
Symbol symbol => symbol.Value,
Function _ => "#<function>",
Keyword keyword => keyword.Value,
List list => PrintCollection("(", ")", list),
Vector vector => PrintCollection("[", "]", vector),
_ => throw new YungException(
$"Tried to print a node of type {expression.GetType().Name}, but this action is not implemented.")
});
public override Verb CreateVerb(string[] tokens)
{
Color(position, length, KeyWords);
var word = tokens[1].ToLower();
Value value;
switch (word)
{
case "false":
value = false;
break;
case "true":
value = true;
break;
case "nil":
value = new Nil();
break;
case "any":
value = new Any();
break;
case "null":
value = new Null();
break;
case "none":
value = new None();
break;
case "ignore":
value = new Ignore();
break;
default:
return(null);
}
result.Value = value;
return(new Push(value));
}
public static (Lst <ODE> odes, Lst <Equation> eqs) FromCRN(CRN crn)
{
(SpeciesValue[] vars, Flow[] flows) = crn.MeanFlow();
Lst <ODE> odes = new Nil <ODE>();
for (int i = vars.Length - 1; i >= 0; i--)
{
odes = new Cons <ODE>(new ODE(new SpeciesFlow(vars[i].symbol), flows[i]), odes);
}
List <SpeciesValue> species = crn.sample.stateMap.species;
Lst <Equation> eqs = new Nil <Equation>();
for (int i = species.Count - 1; i >= 0; i--)
{
eqs = new Cons <Equation>(new Equation(new SpeciesFlow(species[i].symbol), "id", new Lst <Monomial>[1] {
Monomial.Singleton(new Monomial(crn.sample.stateMap.state.Mean(i)))
}), eqs);
}
return(odes, eqs);
}
/// <summary>
/// Get the string of this Unit, by indecating whether you want it full or not.
/// <!--This is not an overrided method,
/// but this is a overloaded method for ToString() method,
/// so I thought it it'd be better to right it here.-->
/// </summary>
/// <param name="fullUnit">
/// if true, it returns a full mode unit string.
/// </param>
/// <returns></returns>
public string ToString(bool fullUnit)
{
if (fullUnit)
{
string myString = string.Empty;
if (Bil != 0)
{
myString += Bil.ToString() + FullTosStringSeparater;
myString += Mil.ToString(FullUnitFormatConvertor) + FullTosStringSeparater;
myString += Kil.ToString(FullUnitFormatConvertor) + FullTosStringSeparater;
myString += Nil.ToString(FullUnitFormatConvertor);
}
else
{
if (Mil != 0)
{
myString += Mil.ToString() + FullTosStringSeparater;
myString += Kil.ToString(FullUnitFormatConvertor) + FullTosStringSeparater;
myString += Nil.ToString(FullUnitFormatConvertor);
}
else
{
if (Kil != 0)
{
myString += Kil.ToString() + FullTosStringSeparater;
myString += Nil.ToString(FullUnitFormatConvertor);
}
else
{
myString += Nil.ToString();
}
}
}
return(myString);
}
else
{
return(ToString());
}
}
public void Visit(Nil nil)
{
_sb.Append("nil");
}
static Nil()
{
Instance = new Nil();
RegisterSymbol(Instance);
}
static _()
{
nil = new Nil();
}
public SExp[] CreateExpressions(IEnumerable<LexerToken> tokens)
{
IEnumerator<LexerToken> itor = tokens.GetEnumerator();
// confirm
if (!itor.MoveNext())
{
const string MSG = "Empty S-Expression.";
throw new ParserException(MSG);
}
itor = tokens.GetEnumerator();
Stack<SExp> stkExp = new Stack<SExp>();
SExp list = new Nil();
bool consing = false;
while (true)
{
if (consing)
{
SExp exp = null;
try { exp = stkExp.Pop(); }
catch
{
const string MSG = "Extra close parenthesis.";
throw new ParserException(MSG);
}
if (exp is __LeftParen)
{
stkExp.Push(list);
list = new Nil();
consing = false;
}
else
{
list = new Cell(exp, list);
}
}
else
{
if (!itor.MoveNext())
{
break;
}
else if (itor.Current is TokenRightParen)
{
consing = true;
}
else
{
SExp exp = CreateAtom(itor.Current);
stkExp.Push(exp);
}
}
}
List<SExp> l = new List<SExp>(stkExp);
l.Reverse();
if (l.Exists(exp=>exp is __LeftParen))
{
string msg = "Unclosed list detected.";
throw new ParserException(msg);
}
return l.ToArray();
}
/// <summary>
/// Encodes the specified output.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
public override int Encode(Stream output, Nil value)
{
return(0);
}
public AstPrinterNode Visit(Nil node)
{
var printer = new AstPrinterNode(node.ToString());
return(printer);
}
static Nil()
{
single = new Nil <a> ();
}
public override void Because()
{
nilString = Nil<string>.Instance;
nilElse = Nil<UnitTestBase>.Instance;
}
public override void CreateVariable(string variableName, bool global = false,
VisibilityType visibility = VisibilityType.Public, bool _override = false)
{
variables[variableName] = new Nil();
visibilityTypes[variableName] = visibility;
}
public override Element BuildElement(Element element)
{
{ // Headings can't contain other headings & list item headings don't become items.
if (element is Heading || element is ListItem)
{
return(element);
}
}
Item? item = null;
Heading?lastHeading = null;
var subs = element switch {
Item i => i.Content,
_ => element.Subs
};
var newSubs = Nil.L <Element>();
if (element is Item ii)
{
newSubs.Add(ii.Title);
}
subs.ForEach(el => {
var newItem = el is Heading h && h.Level <= (lastHeading?.Level ?? 7);
if (item == null)
{
if (newItem)
{
item = Item.FromTitleElement(el);
}
else
{
newSubs.Add(el);
}
}
else
{
if (newItem)
{
newSubs.Add(item);
item = Item.FromTitleElement(el);
}
else
{
item.Subs.Add(el);
}
}
if (newItem)
{
lastHeading = el as Heading;
}
});
if (item != null)
{
newSubs.Add(item);
}
element.Subs = newSubs;
return(element);
}
}
public override void Encode(JsonWriter output, Nil value)
{
}
