protected ReturnValue(ReturnValueType returnValueType, ErrorType errorType, string format, params object[] args)
{
IsSuccess = errorType == ErrorType.None;
ReturnValueType = returnValueType;
ErrorType = errorType;
Message = String.Format(format ?? "", args);
}
public ReturnValue(ReturnValueType type, object pData)
{
m_returnType = type;
switch (m_returnType)
{
case ReturnValueType.STRING: m_stringValue = (string)pData; break;
case ReturnValueType.NUMBER: m_numberValue = pData.GetType() == typeof(float) ? (float)pData : Convert.ToSingle(pData); break;
case ReturnValueType.BOOL: m_boolValue = (bool)pData; break;
case ReturnValueType.ARRAY:
{
m_arrayValue = new SortedDictionary <int, ReturnValue>();
int i = 0;
foreach (object element in (pData as IEnumerable))
{
Type t = element.GetType();
ReturnValue rv = new ReturnValue(SystemTypeToReturnValueType(t), element);
m_arrayValue.Add(i++, rv);
}
}
break;
default:
throw new Exception("Boxing error");
}
}
object DefaultValue(ReturnValueType type)
{
if (type == ReturnValueType.STRING)
{
return("");
}
else if (type == ReturnValueType.BOOL)
{
return(false);
}
else if (type == ReturnValueType.NUMBER)
{
return(0.0f);
}
else if (type == ReturnValueType.RANGE)
{
return(new Range(0, 0, 0));
}
else if (type == ReturnValueType.ARRAY)
{
return(new SortedDictionary <KeyWrapper, object>());
}
else if (type == ReturnValueType.VOID)
{
return(VoidType.voidType);
}
else if (type == ReturnValueType.UNKNOWN_TYPE)
{
return(UnknownType.unknownType);
}
else
{
throw new Error("No default value for " + type);
}
}
public ReturnValue(ReturnValueType type)
{
m_returnType = type;
if(m_returnType == ReturnValueType.ARRAY) {
m_arrayValue = new SortedDictionary<int, ReturnValue>();
}
}
private void assignValue(string variableName, ReturnValue valueToAssign)
{
Assert.IsNotNull(m_currentScope);
//Console.WriteLine("Current scope: " + m_currentScope.getName());
Symbol symbol = m_currentScope.resolve(variableName);
if (symbol == null)
{
throw new InvalidOperationException("Can't resolve variable with name " + variableName);
}
ReturnValueType variableType = symbol.getReturnValueType();
switch (variableType)
{
case ReturnValueType.FLOAT:
float floatValue = valueToAssign.FloatValue;
ReturnValue floatVal = new ReturnValue(floatValue);
m_currentMemorySpace.setValue(variableName, floatVal);
break;
case ReturnValueType.STRING:
string stringValue = valueToAssign.StringValue;
ReturnValue stringVal = new ReturnValue(stringValue);
m_currentMemorySpace.setValue(variableName, stringVal);
break;
default:
throw new InvalidOperationException("Can't assign to a variable of type + " + variableType);
}
}
public ReturnValue(ReturnValueType type)
{
m_returnType = type;
if (m_returnType == ReturnValueType.ARRAY)
{
m_arrayValue = new SortedDictionary <int, ReturnValue>();
}
}
public void setType(ReturnValueType newType)
{
m_returnType = newType;
if (m_returnType == ReturnValueType.ARRAY && m_arrayValue == null)
{
m_arrayValue = new SortedDictionary <int, ReturnValue>();
}
}
private void VariableDeclaration()
{
ReturnValueType type = (CurrentNode as AST_VariableDeclaration).Type;
string variableName = (CurrentNode as AST_VariableDeclaration).Name;
object initValue = DefaultValue(type);
m_currentScope.setValue(variableName, initValue);
}
private void AssignmentSignal()
{
string variableName = (CurrentNode as AST_Assignment).VariableName;
ReturnValue expressionValue = PopValue();
ReturnValueType type = m_currentScope.getValue(variableName).getReturnValueType();
ReturnValue convertedValue = ConvertToType(expressionValue, type);
m_currentScope.setValue(variableName, convertedValue);
}
public FunctionSymbol(Scope enclosingScope, string name, ReturnValueType type, AST functionDefinitionNode)
: base(Scope.ScopeType.FUNCTION_SCOPE, name, enclosingScope)
{
Debug.Assert(enclosingScope != null);
Debug.Assert(functionDefinitionNode != null);
m_enclosingScope = enclosingScope;
m_functionDefinitionNode = functionDefinitionNode;
m_returnValueType = type;
}
public FunctionSymbol(Scope enclosingScope, string name, ReturnValueType type, AST functionDefinitionNode)
: base(Scope.ScopeType.FUNCTION_SCOPE, name, enclosingScope)
{
Debug.Assert(enclosingScope != null);
Debug.Assert(functionDefinitionNode != null);
m_enclosingScope = enclosingScope;
m_functionDefinitionNode = functionDefinitionNode;
m_returnValueType = type;
}
public static async Task <ReturnValueType> PresentDialogWithReturnValue(string message, string confirmText = "OK")
{
ReturnValueType retVal = ReturnValueType.Undefined;
var messageDialog = new MessageDialog(message);
messageDialog.Commands.Add(new UICommand(confirmText, command => { retVal = ReturnValueType.OK; }));
messageDialog.Commands.Add(new UICommand("Cancel", command => { retVal = ReturnValueType.Cancel; }));
messageDialog.DefaultCommandIndex = 1;
messageDialog.CancelCommandIndex = 1;
await messageDialog.ShowAsync();
return(retVal);
}
private ReturnValue ConvertToType(ReturnValue valueToConvert, ReturnValueType type)
{
#if WRITE_CONVERT_INFO
Console.WriteLine("Converting from " + valueToConvert.getReturnValueType() +
" (" + valueToConvert.ToString() + ")" +
" to " + type);
#endif
ReturnValue result = null;
if (type == ReturnValueType.VOID)
{
throw new Error("Can't convert to void.");
}
else if (type == ReturnValueType.UNKNOWN_TYPE)
{
// Don't convert but make a new copy with the same type
type = valueToConvert.getReturnValueType();
}
if (type == ReturnValueType.ARRAY)
{
result = new ReturnValue(valueToConvert.ArrayValue);
}
else if (type == ReturnValueType.BOOL)
{
result = new ReturnValue(valueToConvert.BoolValue);
}
else if (type == ReturnValueType.NUMBER)
{
result = new ReturnValue(valueToConvert.NumberValue);
}
else if (type == ReturnValueType.STRING)
{
result = new ReturnValue(valueToConvert.StringValue);
}
else
{
throw new Exception("Can't happen!");
}
#if WRITE_CONVERT_INFO
Console.WriteLine("Result: " + result.ToString());
#endif
return(result);
}
private void varDeclaration(AST tree)
{
string typeName = tree.getChild(0).getTokenString();
ReturnValueType variableType = ReturnValue.getReturnValueTypeFromString(typeName);
string variableName = tree.getChild(1).getTokenString();
switch (variableType)
{
case ReturnValueType.FLOAT:
m_currentMemorySpace.setValue(variableName, new ReturnValue(0.0f));
break;
case ReturnValueType.STRING:
m_currentMemorySpace.setValue(variableName, new ReturnValue(0.0f));
break;
default:
throw new InvalidOperationException("Can't declare a variable of type " + typeName);
}
}
private void evaluateReferencesForVAR_DECLARATION(AST tree)
{
AST_VariableDeclaration varDeclaration = tree as AST_VariableDeclaration;
ReturnValueType typeToDeclare = varDeclaration.Type;
string variableName = varDeclaration.Name;
if (m_currentScope.isDefined(variableName))
{
m_errorHandler.errorOccured(
new Error("There is already a variable called '" + variableName + "'",
Error.ErrorType.LOGIC,
tree.getToken().LineNr,
tree.getToken().LinePosition));
}
else
{
m_currentScope.define(new VariableSymbol(variableName, typeToDeclare));
#if WRITE_DEBUG_INFO
Console.WriteLine("Defined variable with name " + variableName + " and type " + typeToDeclare + " (on line " + tree.getToken().LineNr + ")" + " in " + m_currentScope);
#endif
}
}
private void evaluateFunctionScope(AST tree)
{
// Define function name
ReturnValueType returnType = ReturnValue.getReturnValueTypeFromString(tree.getChild(0).getTokenString());
string functionName = tree.getChild(1).getTokenString();
Symbol functionScope = new FunctionSymbol(m_currentScope, functionName, returnType, tree);
m_globalScope.define(functionScope); // all functions are saved in the global scope
m_currentScope = (Scope)functionScope;
AST_FunctionDefinitionNode functionCallNode = (AST_FunctionDefinitionNode)(tree);
functionCallNode.setScope((Scope)functionScope);
#if WRITE_DEBUG_INFO
Console.WriteLine("\nDefined function with name " + functionName + " and return type " + returnType);
#endif
// Process the body of the function
evaluateScopeDeclarations(tree.getChild(3));
m_currentScope = m_currentScope.getEnclosingScope(); // pop scope
}
public ReturnValue(ReturnValueType type, object pData)
{
m_returnType = type;
switch (m_returnType)
{
case ReturnValueType.STRING: m_stringValue = (string)pData; break;
case ReturnValueType.NUMBER: m_numberValue = pData.GetType() == typeof(float) ? (float)pData : Convert.ToSingle(pData); break;
case ReturnValueType.BOOL: m_boolValue = (bool)pData; break;
case ReturnValueType.ARRAY:
{
m_arrayValue = new SortedDictionary<int, ReturnValue>();
int i = 0;
foreach(object element in (pData as IEnumerable))
{
Type t = element.GetType();
ReturnValue rv = new ReturnValue(SystemTypeToReturnValueType(t), element);
m_arrayValue.Add(i++, rv);
}
}
break;
default:
throw new Exception("Boxing error");
}
}
public AST_VariableDeclaration(Token token, ReturnValueType type, string name)
: base(token)
{
m_type = type;
m_name = name;
}
public void setType(ReturnValueType newType)
{
m_returnType = newType;
if(m_returnType == ReturnValueType.ARRAY && m_arrayValue == null) {
m_arrayValue = new SortedDictionary<int, ReturnValue>();
}
}
public void setVoid()
{
m_returnType = ReturnValueType.VOID;
}
public ReturnValue()
{
m_returnType = ReturnValueType.VOID;
}
public ReturnValue(float nr)
{
this.NumberValue = nr;
m_returnType = ReturnValueType.NUMBER;
}
public ReturnValue(string text)
{
this.StringValue = text;
m_returnType = ReturnValueType.STRING;
}
public static FunctionDefinition[] CreateDefinitions(object o, Type t)
{
List <FunctionDefinition> methods = new List <FunctionDefinition>();
Dictionary <string, FunctionDocumentation> HelpInfo = new Dictionary <string, FunctionDocumentation>();
MethodInfo[] methodInfos = t.GetMethods();
foreach (MethodInfo methodI in methodInfos)
{
if (methodI.Name.StartsWith("API_"))
{
SprakAPI[] help = (SprakAPI[])methodI.GetCustomAttributes(typeof(SprakAPI), true);
if (help.Length > 0)
{
//Console.WriteLine("found " + String.Join( ",", help[0].Values));
List <string> parameterHelp = new List <string>();
for (int i = 1; i < help[0].Values.Length; i++)
{
parameterHelp.Add(help[0].Values[i]);
}
string shortname = methodI.Name.Substring(4);
FunctionDocumentation fd = new FunctionDocumentation(help[0].Values[0], parameterHelp.ToArray());
HelpInfo.Add(shortname, fd);
}
}
}
foreach (MethodInfo mi in methodInfos)
{
if (mi.Name.StartsWith("API_"))
{
//Console.WriteLine("parsing " + mi.Name + " return Type " + mi.ReturnType.Name);
string shortname = mi.Name.Substring(4);
if (mi.ReturnType.IsArray)
{
throw new Exception("FunctionDefinitionCreator can't handle array return value!");
}
List <ReturnValueType> parameterTypes = new List <ReturnValueType>();
List <string> parameterNames = new List <string>();
List <string> parameterTypeNames = new List <string>();
foreach (ParameterInfo pi in mi.GetParameters())
{
if (pi.ParameterType.IsArray)
{
throw new Exception("FunctionDefinitionCreator can't handle array parameters!");
}
parameterNames.Add(pi.Name);
parameterTypes.Add(ReturnValue.SystemTypeToReturnValueType(pi.ParameterType));
parameterTypeNames.Add(ReturnValue.SystemTypeToReturnValueType(pi.ParameterType).ToString().ToLower());
}
MethodInfo lamdaMethodInfo = mi;
ExternalFunctionCreator.OnFunctionCall function = (retvals) =>
{
int i = 0;
ParameterInfo[] realParamInfo = lamdaMethodInfo.GetParameters();
List <object> parameters = new List <object>();
foreach (ReturnValue r in retvals)
{
if (realParamInfo[i++].ParameterType == typeof(int))
{
parameters.Add(Convert.ToInt32(r.Unpack()));
}
else
{
parameters.Add(r.Unpack());
}
}
//Console.WriteLine("supplied parameter count" + parameters.Count + " neededParamter count " + lamdaMethodInfo.GetParameters().Length);
object result = lamdaMethodInfo.Invoke(o, parameters.ToArray());
if (lamdaMethodInfo.ReturnType == typeof(void))
{
return(new ReturnValue(ReturnValueType.VOID));
}
else
{
return(new ReturnValue(ReturnValue.SystemTypeToReturnValueType(lamdaMethodInfo.ReturnType), result));
}
};
ReturnValueType returnValueType = ReturnValue.SystemTypeToReturnValueType(mi.ReturnType);
FunctionDocumentation doc;
if (HelpInfo.TryGetValue(shortname, out doc))
{
methods.Add(new FunctionDefinition(returnValueType.ToString(), shortname, parameterTypeNames.ToArray(), parameterNames.ToArray(), function, doc));
}
else
{
methods.Add(new FunctionDefinition(returnValueType.ToString(), shortname, parameterTypeNames.ToArray(), parameterNames.ToArray(), function, FunctionDocumentation.Default()));
}
}
}
return(methods.ToArray());
}
public ReturnValue(bool boolean)
{
this.BoolValue = boolean;
m_returnType = ReturnValueType.BOOL;
}
public ReturnValue(SortedDictionary<int, ReturnValue> arrayValue)
{
this.ArrayValue = arrayValue;
m_returnType = ReturnValueType.ARRAY;
}
static List <FunctionDefinition> CreateFunctionDefinitions(object pProgramTarget, Dictionary <string, FunctionDocumentation> functionDocumentations, MethodInfo[] methodInfos)
{
List <FunctionDefinition> functionDefinitions = new List <FunctionDefinition>();
foreach (MethodInfo methodInfo in methodInfos)
{
if (!methodInfo.Name.StartsWith("API_"))
{
continue;
}
MethodInfo lambdaMethodInfo = methodInfo; // "hard copy" because of c# lambda rules
string shortname = lambdaMethodInfo.Name.Substring(4);
List <ReturnValueType> parameterTypes = new List <ReturnValueType> ();
List <string> parameterNames = new List <string> ();
List <string> parameterTypeNames = new List <string> ();
foreach (ParameterInfo parameterInfo in lambdaMethodInfo.GetParameters())
{
var t = ReturnValueConversions.SystemTypeToReturnValueType(parameterInfo.ParameterType);
//Console.WriteLine("Registering parameter '" + parameterInfo.Name + "' (" + parameterInfo.ParameterType + ") with ReturnValueType " + t + " for function " + shortname);
parameterNames.Add(parameterInfo.Name);
parameterTypes.Add(t);
parameterTypeNames.Add(t.ToString().ToLower());
}
ExternalFunctionCreator.OnFunctionCall function = (sprakArguments => {
ParameterInfo[] realParamInfo = lambdaMethodInfo.GetParameters();
if (sprakArguments.Count() != realParamInfo.Length)
{
throw new Error("Should call '" + shortname + "' with " + realParamInfo.Length + " argument" + (realParamInfo.Length == 1 ? "" : "s"));
}
int i = 0;
foreach (object sprakArg in sprakArguments)
{
//Console.WriteLine(string.Format("Parameter {0} in function {1} is of type {2}", i, shortname, realParamInfo[i].ParameterType));
var realParamType = realParamInfo [i].ParameterType;
if (sprakArg.GetType() == typeof(SortedDictionary <KeyWrapper, object>))
{
sprakArguments[i] = (sprakArg as SortedDictionary <KeyWrapper, object>).Values.ToArray();
}
if (sprakArg.GetType() == typeof(int))
{
// YES, this is kind of a HACK (allowing definitions with int arguments, making them work like the were floats. Remove later!
sprakArguments[i] = (float)sprakArg;
realParamType = typeof(int);
}
if (acceptableTypes.Contains(realParamType))
{
// OK
}
else
{
throw new Error("Can't deal with parameter " + i.ToString() + " of type " + realParamType + " in function " + shortname);
}
i++;
}
//Console.WriteLine("supplied parameter count" + parameters.Count + " neededParamter count " + lamdaMethodInfo.GetParameters().Length);
object result = null;
try {
/*
* Console.WriteLine("Will call " + shortname + " with sprak arguments:");
* int j = 0;
* foreach(var a in sprakArguments) {
* Console.WriteLine(" Argument " + (j++) + ": " + ReturnValueConversions.PrettyStringRepresenation(a) + " (" + a.GetType() + ")");
* }
*/
result = lambdaMethodInfo.Invoke(pProgramTarget, sprakArguments.ToArray());
}
catch (System.Reflection.TargetInvocationException e) {
//Console.WriteLine("Got an exception when calling the lambda: " + e.ToString());
//Console.WriteLine("The base exception: " + e.GetBaseException().ToString());
throw e.GetBaseException();
}
// HACK
if (lambdaMethodInfo.ReturnType == typeof(int))
{
return((float)(int)result);
}
if (lambdaMethodInfo.ReturnType.IsSubclassOf(typeof(Array)))
{
var dictArray = new SortedDictionary <KeyWrapper, object>();
int j = 0;
foreach (var o in (Array)result)
{
//Console.WriteLine(" - " + o.ToString());
dictArray.Add(new KeyWrapper((float)j++), o);
}
//Console.WriteLine("Converted object[] to SortedDictionary when returning from " + shortname + ": " + ReturnValueConversions.PrettyStringRepresenation(dictArray));
return(dictArray);
}
if (!acceptableTypes.Contains(lambdaMethodInfo.ReturnType))
{
throw new Error("Function '" + shortname + "' can't return value of type " + lambdaMethodInfo.ReturnType.ToString());
}
if (lambdaMethodInfo.ReturnType == typeof(void))
{
//Console.WriteLine("Returning void from " + shortname);
return(VoidType.voidType);
}
else
{
//Console.WriteLine("Returning from " + shortname + ": " + ReturnValueConversions.PrettyStringRepresenation(result));
return(result);
}
});
ReturnValueType returnValueType = ReturnValueConversions.SystemTypeToReturnValueType(lambdaMethodInfo.ReturnType);
FunctionDocumentation doc;
if (functionDocumentations.ContainsKey(shortname))
{
doc = functionDocumentations [shortname];
}
else
{
doc = FunctionDocumentation.Default();
}
functionDefinitions.Add(new FunctionDefinition(
returnValueType.ToString(),
shortname,
parameterTypeNames.ToArray(),
parameterNames.ToArray(),
function, // The lambda
doc));
}
return(functionDefinitions);
}
public AST_VariableDeclaration(Token token, ReturnValueType type, string name)
: base(token)
{
m_type = type;
m_name = name;
}
public static object ChangeTypeBasedOnReturnValueType(object obj, ReturnValueType type)
{
//Console.WriteLine("Will try to change obj '" + PrettyStringRepresenation(obj) + "' of type " + obj.GetType() + " to return value type " + type);
if (type == ReturnValueType.STRING)
{
return(PrettyStringRepresenation(obj));
}
else if (type == ReturnValueType.NUMBER)
{
if (obj.GetType() == typeof(float))
{
return((float)obj);
}
if (obj.GetType() == typeof(int))
{
// This is a HACK since I couldn't get all obj:s to be floats, some ints were getting trough even though I tried to weed them out :/
return((float)(int)obj);
}
else if (obj.GetType() == typeof(string))
{
try {
return((float)Convert.ToDouble((string)obj, CultureInfo.InvariantCulture));
}
catch (System.FormatException) {
throw new Error("Can't convert " + obj.ToString() + " to a number");
}
}
}
else if (type == ReturnValueType.RANGE)
{
return((Range)obj);
}
else if (type == ReturnValueType.ARRAY)
{
if (obj.GetType() == typeof(object[]))
{
return(obj);
}
else if (obj.GetType() == typeof(SortedDictionary <KeyWrapper, object>))
{
//Console.WriteLine("Not changing type of array " + PrettyStringRepresenation(obj));
return(obj);
}
else if (obj.GetType() == typeof(Range))
{
return(obj);
}
else if (obj.GetType() == typeof(string))
{
var a = new SortedDictionary <KeyWrapper, object>();
string s = (string)obj;
for (int i = 0; i < s.Length; i++)
{
a.Add(new KeyWrapper((float)i), s);
}
return(a);
}
else
{
throw new Error("Can't convert " + obj.ToString() + " to an array");
}
}
else if (type == ReturnValueType.BOOL)
{
return((bool)obj);
}
else if (type == ReturnValueType.UNKNOWN_TYPE)
{
return(obj);
}
throw new Exception("Can't change type from " + obj.GetType() + " to " + type);
}
public static ReturnValue Ok(ReturnValueType returnValueType, string format = "", params object[] args)
{
return(new ReturnValue(returnValueType, ErrorType.None, format, args));
}
public static ReturnValue Error(ReturnValueType returnValueType, ErrorType errorType, string format, params object[] args)
{
return(new ReturnValue(returnValueType, errorType, format, args));
}
private void AddFunc <T>(Func <TX, T> func, ReturnValueType returnValueType)
{
_funcs.Add(c => ReturnValue <T> .Ok(func(c), returnValueType));
}
public VariableSymbol(string name, ReturnValueType type)
{
m_name = name;
m_returnValueType = type;
}
public VariableSymbol(string name, ReturnValueType type)
{
m_name = name;
m_returnValueType = type;
}
