public static Water.Blocks.Block GetBlock(Water.List list)
{
if (list == null || list.Count == 0)
{
return(null);
}
if (!(list[0] is Water.Identifier))
{
return(null);
}
Water.Identifier identifier = (Water.Identifier)list[0];
object block = Water.Environment.Identify(identifier.Value);
if (block == null)
{
return(null);
}
if (!(block is Water.Blocks.Block))
{
return(null);
}
return((Water.Blocks.Block)block);
}
public static object Apply(object command, Water.List args)
{
if (command is Water.List)
{
Water.List list = (Water.List)command;
object command2 = Apply(list.First(), list.NotFirst());
//TODO I don't like this.
if (command2 == null && args.Count == 0)
{
return(null);
}
return(Apply(command2, args));
}
else if (command is Water.Identifier)
{
Water.Identifier identifier = (Water.Identifier)command;
object command2 = Evaluate(identifier);
if (command2 == null)
{
throw new Water.Error(identifier.Value + " is not defined.");
}
return(Apply(command2, args));
}
else
{
Water.Operator op = (Water.Operator)command;
return(op.Evaluate(args));
}
}
public override void Evaluate(Water.List expressions, Water.List statements)
{
if (!(expressions[0] is Water.Identifier))
{
throw new Water.Error("Invalid arguments.\n\t" + expressions.ToString());
}
string name = ((Water.Identifier)expressions[0]).Value;
string namespace_ = (string)Water.Environment.Identify("_Namespace");
if (namespace_ != null && namespace_.Length > 0)
{
name = namespace_ + "." + name;
}
Water.Functions.Function function = new Water.Functions.Function(name);
for (int i = 1; i < expressions.Count; i++)
{
if (expressions[i] is Water.Identifier)
{
Water.Identifier identifier = (Water.Identifier)expressions[i];
function.Parameters.Add(identifier);
}
else if ((expressions[i] is Water.Quote))
{
Water.Quote quote = (Water.Quote)expressions[i];
Water.Identifier identifier = (Water.Identifier)quote.Expression;
function.Parameters.Add(new Water.Identifier("'" + identifier.Value));
}
else
{
throw new Water.Error("'" + expressions[i] + "' is not a valid parameter name.");
}
}
foreach (Water.Statement statement in statements)
{
function.Statements.Add(statement);
}
bool hasOptional = HasOptional(function.Parameters);
bool hasRest = HasRest(function.Parameters);
if (hasOptional && hasRest)
{
throw new Water.Error("Cannot have both optional and rest parameters: " + name);
}
else if (hasRest)
{
CheckRestLegal(name, function.Parameters);
}
Water.Environment.DefineConstant(function.Name, function);
}
public static void Generate(object value, Water.TextWriter writer)
{
#region Generate
if (value == null)
{
writer.WriteLine("null");
}
else if (value is bool)
{
bool b = (bool)value;
writer.WriteLine(b.ToString());
}
else if (value is byte)
{
byte n = (byte)value;
writer.WriteLine(n.ToString());
}
else if (value is char)
{
char ch = (char)value;
writer.WriteLine(ch.ToString());
}
else if (value is short)
{
short n = (short)value;
writer.WriteLine(n.ToString());
}
else if (value is int)
{
int n = (int)value;
writer.WriteLine(n.ToString());
}
else if (value is long)
{
long n = (long)value;
writer.WriteLine(n.ToString());
}
else if (value is decimal)
{
decimal d = (decimal)value;
writer.WriteLine(d.ToString());
}
else if (value is float)
{
float f = (float)value;
writer.WriteLine(f.ToString());
}
else if (value is double)
{
double d = (double)value;
writer.WriteLine(d.ToString());
}
else if (value is System.DateTime)
{
System.DateTime dt = (System.DateTime)value;
writer.WriteLine(dt.ToString());
}
else if (value is Water.Identifier)
{
Water.Identifier identifier = (Water.Identifier)value;
writer.WriteLine(identifier.Value);
}
else if (value is Water.Quote)
{
Water.Quote quote = (Water.Quote)value;
writer.Write("\'");
Generate(quote.Expression, writer);
}
else if (value is Water.Comma)
{
Water.Comma comma = (Water.Comma)value;
writer.Write(",");
Generate(comma.Expression, writer);
}
else if (value is byte[])
{
byte[] bytes = (byte[])value;
writer.Write("[");
writer.Write(System.Convert.ToBase64String(bytes));
writer.WriteLine("]");
}
else if (value is string)
{
string s = (string)value;
writer.WriteLine("\"" + Escape(s) + "\"");
}
else if (value is System.Enum)
{
System.Enum enum_ = (System.Enum)value;
writer.WriteLine(enum_.ToString());
}
else if ((value is System.Collections.IDictionary))
{
System.Collections.IDictionary dictionary = (System.Collections.IDictionary)value;
writer.WriteLine("{");
writer.Indent();
bool first = true;
foreach (object key in dictionary.Keys)
{
try
{
object dictionaryValue = dictionary[key];
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
writer.Write(key.ToString() + ": ");
Generate(dictionaryValue, writer);
}
catch (System.Exception exception)
{
string thisIsAHackToIgnoreCompilerWarning = exception.Message;
}
}
writer.Unindent();
writer.WriteLine("}");
}
else if ((value is Water.Dictionary))
{
//Water.Dictionary dictionary = (Water.Dictionary)value;
//DUP
writer.WriteLine("{");
writer.Indent();
bool first = true;
System.Type type = value.GetType();
foreach (System.Reflection.FieldInfo fieldInfo in type.GetFields())
{
if (!fieldInfo.IsStatic)
{
try
{
object fieldValue = fieldInfo.GetValue(value);
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
writer.Write(fieldInfo.Name + ": ");
Generate(fieldValue, writer);
}
catch (System.Exception exception)
{
string thisIsAHackToIgnoreCompilerWarning = exception.Message;
}
}
}
System.ComponentModel.PropertyDescriptorCollection propertyDescriptors = System.ComponentModel.TypeDescriptor.GetProperties(value);
foreach (System.ComponentModel.PropertyDescriptor propertyDescriptor in propertyDescriptors)
{
try
{
object propertyValue = propertyDescriptor.GetValue(value);
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
writer.Write(propertyDescriptor.Name + ": ");
Generate(propertyValue, writer);
}
catch (System.Exception exception)
{
string thisIsAHackToIgnoreCompilerWarning = exception.Message;
}
}
writer.Unindent();
writer.WriteLine("}");
}
else if (Water.Instructions.IsList(value))
{
System.Collections.IEnumerable list = (System.Collections.IEnumerable)value;
writer.WriteLine("(");
writer.Indent();
bool first = true;
foreach (object item in list)
{
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
Generate(item, writer);
}
writer.Unindent();
writer.WriteLine(")");
}
else
{
//DUP
writer.WriteLine("{");
writer.Indent();
bool first = true;
System.Type type = value.GetType();
foreach (System.Reflection.FieldInfo fieldInfo in type.GetFields())
{
if (!fieldInfo.IsStatic)
{
try
{
object fieldValue = fieldInfo.GetValue(value);
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
writer.Write(fieldInfo.Name + ": ");
Generate(fieldValue, writer);
}
catch (System.Exception exception)
{
string thisIsAHackToIgnoreCompilerWarning = exception.Message;
}
}
}
System.ComponentModel.PropertyDescriptorCollection propertyDescriptors = System.ComponentModel.TypeDescriptor.GetProperties(value);
foreach (System.ComponentModel.PropertyDescriptor propertyDescriptor in propertyDescriptors)
{
try
{
object propertyValue = propertyDescriptor.GetValue(value);
if (writer.NewlineString.Length == 0)
{
if (first)
{
first = false;
}
else
{
writer.Write(" ");
}
}
writer.Write(propertyDescriptor.Name + ": ");
Generate(propertyValue, writer);
}
catch (System.Exception exception)
{
string thisIsAHackToIgnoreCompilerWarning = exception.Message;
}
}
writer.Unindent();
writer.WriteLine("}");
}
writer.Flush();
#endregion
}
private string GetUnevaluated(Water.Identifier parameter)
{
return(parameter.Value.Substring(1));
}
private bool IsUnevaluated(Water.Identifier parameter)
{
return(parameter.Value.StartsWith("'"));
}
private string GetOptional(Water.Identifier parameter)
{
return(parameter.Value.Substring(1));
}
public static bool IsOptional(Water.Identifier parameter)
{
return(parameter.Value.StartsWith("?"));
}
public static bool IsRest(Water.Identifier parameter)
{
return(parameter.Value.StartsWith("*"));
}
public override void Evaluate(Water.List expressions, Water.List statements)
{
//Push a stack frame
Water.Environment.Push();
// Evaluate local variables.
Water.List expressions_to_eval = expressions.Copy();
Water.List values = new Water.List();
bool hasRest = false;
foreach (Water.Identifier parameter in this._parameters)
{
if (hasRest)
{
throw new Water.Error("Cannot have parameters after a rest parameter in function " + this._name);
}
if (IsRest(parameter))
{
//Add the rest.
Water.List rest = new Water.List();
foreach (Water.Identifier expression in expressions_to_eval)
{
rest.Add(expression);
}
expressions_to_eval.Clear();
values.Add(rest);
hasRest = true;
}
else if (IsOptional(parameter))
{
//If it doesn't exist add null.
if (expressions_to_eval.Count == 0)
{
values.Add(null);
}
else
{
Water.Identifier value = (Water.Identifier)expressions_to_eval.First();
values.Add(value);
expressions_to_eval = expressions_to_eval.NotFirst();
}
}
else if (IsUnevaluated(parameter))
{
values.Add(expressions_to_eval.First());
expressions_to_eval = expressions_to_eval.NotFirst();
}
else
{
//Throw exception if null.
if (expressions_to_eval.Count == 0)
{
throw new Water.Error("Parameter is required: " + parameter.Value);
}
else
{
Water.Identifier value = (Water.Identifier)expressions_to_eval.First();
if (value == null)
{
throw new Water.Error("Parameter is required: " + parameter.Value);
}
values.Add(value);
expressions_to_eval = expressions_to_eval.NotFirst();
}
}
}
if (expressions_to_eval.Count > 0)
{
throw new Water.Error("Too many expressions passed to function: " + this._name);
}
// Push local variables.
int i = 0;
foreach (Water.Identifier parameter in this._parameters)
{
if (Water.Environment.IsConstant(parameter.Value))
{
throw new Water.Error("Constant \"" + parameter.Value + "\" is already defined.");
}
if (IsOptional(parameter))
{
string name = GetOptional(parameter);
Water.Environment.DefineVariable(name, values[i]);
}
else if (IsRest(parameter))
{
string name = GetRest(parameter);
Water.Environment.DefineVariable(name, values[i]);
}
else if (IsUnevaluated(parameter))
{
string name = GetUnevaluated(parameter);
Water.Environment.DefineVariable(name, values[i]);
}
else
{
Water.Environment.DefineVariable(parameter.Value, values[i]);
}
i++;
}
Water.Environment.DefineVariable("_Statements", statements);
//Evaluate each statement.
Water.Interpreter.Interpret(new StatementIterator(this._statements, false));
//Pop a stack frame.
Water.Environment.Pop();
}
private string GetOptional(Water.Identifier parameter)
{
return(parameter.Value.Substring(1));
//return parameter.Value.Substring(0, parameter.Value.Length - 1);
}
private bool IsOptional(Water.Identifier parameter)
{
return(parameter.Value.StartsWith("?"));
//return parameter.Value.EndsWith("?");
}
private bool IsRest(Water.Identifier parameter)
{
return(parameter.Value.StartsWith("*"));
//return parameter.Value.EndsWith("*");
}
public static object EvaluateIdentifier(Water.Identifier identifier)
{
string name = identifier.Value;
object value = Water.Environment.Identify(name);
if (value != null)
{
//Exact match
return(value);
}
//Break it down.
System.Text.StringBuilder tracker = new System.Text.StringBuilder();
System.IO.TextReader reader = new System.IO.StringReader(name);
string segment = GetSegment(reader);
tracker.Append(segment);
value = Water.Environment.Identify(segment);
segment = "";
while (reader.Peek() != -1)
{
if (value == null)
{
throw new Water.Error(identifier.Value + " is not defined.");
}
char ch = (char)reader.Read();
if (ch == '[')
{
value = ApplyIndexer(GetIndexer(reader), value);
segment = "";
}
else if (ch == '.')
{
segment += GetSegment(reader);
if (IsProperty(value, segment))
{
tracker.Append(".");
tracker.Append(segment);
value = ApplyProperty(segment, value);
segment = "";
}
else if (IsMethod(value, segment))
{
tracker.Append(".");
tracker.Append(segment);
if (reader.Peek() != -1)
{
throw new Water.Error(identifier.Value + " is not defined.");
}
return(new Water.Method(value, segment));
}
else
{
segment += ".";
}
}
}
if (segment.Length > 0)
{
throw new Water.Error(identifier.Value + " is not defined.");
}
return(value);
}
