public void Callback(Node node)
{
if (node is ITypedNode)
{
ITypedNode theNode = node as ITypedNode;
theNode.Type = mapper.Map(theNode.Type);
}
if (node is ManageField)
{
ManageField theNode = node as ManageField;
theNode.Field = mapper.Map(theNode.Field);
}
if (node is MethodBodyBlock)
{
MethodBodyBlock body = node as MethodBodyBlock;
foreach (Variable var in body.Variables)
{
var.Type = mapper.Map(var.Type);
}
body.ReturnType = mapper.Map(body.ReturnType);
}
if (node is CallMethod)
{
CallMethod call = node as CallMethod;
ResidualMethod id = Specialization.GetResidualMethod(call);
if (id != null)
{
MethodBodyBlock mbb = mapper.Holder[id];
node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
call.MethodWithParams = new MethodInfoExtention(mapper.Map(mbb), call.IsVirtCall, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
}
else
{
call.MethodWithParams = mapper.Map(call.MethodWithParams);
}
}
if (node is NewObject)
{
NewObject newObj = node as NewObject;
ResidualMethod id = Specialization.GetResidualMethod(node);
if (id != null)
{
MethodBodyBlock mbb = mapper.Holder[id];
newObj.CtorWithParams = new MethodInfoExtention(mapper.Map(mbb), false, mapper.Map(GetParamTypes(mbb, id.IsConstructor)));
node.Options["HasPseudoParameter"] = mapper.HasPseudoParameter(mbb);
}
else
{
newObj.CtorWithParams = mapper.Map(newObj.CtorWithParams);
}
}
if (node is CreateDelegate)
{
CreateDelegate crDel = node as CreateDelegate;
//Andrew TODO: Map this node...
}
// Graph should be verified AFTER the metadata is resolved
}
//TODO move this method to DataDefinition
private DataType GetTypeDefinition(SymbolTable table, Node symbol)
{
var data = symbol as DataDefinition;
if (data != null)
{
var dataCondition = data as DataCondition;
if (dataCondition != null)
{
return(dataCondition.CodeElement().DataType);
}
DataDescriptionEntry entry;
if (data.CodeElement is DataDescriptionEntry)
{
entry = (DataDescriptionEntry)data.CodeElement;
}
else
if (data.CodeElement is DataRedefinesEntry)
{
var redefines = (DataRedefinesEntry)data.CodeElement;
var node = GetSymbol(table, redefines.RedefinesDataName);
if (node is DataDescription)
{
entry = (DataDescriptionEntry)node.CodeElement;
}
else
{
entry = GetDataDescriptionEntry(table, redefines);
}
}
else
{
throw new NotImplementedException(data.CodeElement.GetType().Name);
}
if (entry == null)
{
return(null);
}
if (entry.UserDefinedDataType == null)
{
return(entry.DataType); //not a custom type
}
}
ITypedNode typed = symbol as ITypedNode;
if (typed == null)
{
return(null); // symbol untyped
}
var types = table.GetTypes(typed);
if (types.Count != 1)
{
return(null); // symbol type not found or ambiguous
}
return(types[0].DataType);
}
public IList <TypeDefinition> GetTypes(ITypedNode symbol)
{
var types = new List <TypeDefinition>();
var list = GetType(symbol.DataType.Name);
foreach (var type in list)
{
types.Add(type);
}
return(types);
}
public override void OnInspectorGUI()
{
Node myTarget = (Node)target;
EditorGUI.BeginChangeCheck();
if (myTarget is INodeCollection || NameEditable)
{
EditorGUIExtension.SimpleBox("", 5, "", delegate()
{
myTarget.Name = EditorGUILayout.TextField("Name", myTarget.Name);
});
}
else if (myTarget is ITypedNode)
{
ITypedNode t = (ITypedNode)myTarget;
EditorGUIExtension.SimpleBox("", 5, "", delegate()
{
if (_typePopup == null)
{
int index = 0;
List <string> names = new List <string>();
for (int cnt = 0; cnt < t.AllowedTypes.Count; cnt++)
{
if (t.Type == t.AllowedTypes[cnt])
{
index = cnt;
}
names.Add(TypeUtils.GetPrettyName(t.AllowedTypes[cnt]));
}
_typePopup = new SmartPopup(names, index);
}
if (_typePopup.Draw("Value Type"))
{
t.Type = t.AllowedTypes[_typePopup.Index];
}
});
}
EditorGUILayout.Space();
onGUI();
if (EditorGUI.EndChangeCheck())
{
myTarget.HasChanges = true;
}
}
/// <summary>
/// Gets a node's type as a string
/// </summary>
/// <param name="typedNode">The node to get the type of</param>
/// <returns>A string describing the type of the node</returns>
private static string GetTypeString(ITypedNode typedNode)
{
return($"Type: {(typedNode.Type is null ? "not set" : typedNode.Type.ToString())}");
}
//TODO move this method to DataDefinition
/// <summary>
/// Allows to get DataType of a DataDefinition Node
/// </summary>
/// <param name="node"></param>
/// <param name="symbol"></param>
/// <param name="isReadDictionary"></param>
/// <returns></returns>
private static DataDefinition GetDataDefinitionType(Node node, Node symbol, bool isReadDictionary)
{
var data = symbol as DataDefinition;
if (data != null)
{
var dataCondition = data as DataCondition;
if (dataCondition != null)
{
return(new GeneratedDefinition(dataCondition.CodeElement().DataType.Name,
dataCondition.CodeElement().DataType));
}
DataDescriptionEntry entry;
var descriptionEntry = data.CodeElement as DataDescriptionEntry;
if (descriptionEntry != null)
{
entry = descriptionEntry;
}
else if (data.CodeElement as DataRedefinesEntry != null)
{
var redefines = (DataRedefinesEntry)data.CodeElement;
var searchedDataDefinition = node.GetDataDefinitionForQualifiedName(redefines.RedefinesDataName.URI, isReadDictionary);
if (searchedDataDefinition as DataDescription != null)
{
entry = (DataDescriptionEntry)searchedDataDefinition.CodeElement;
}
else
{
entry = GetDataDescriptionEntry(node, redefines, isReadDictionary);
}
}
else if (data is IndexDefinition)
{
entry = null;
}
else
{
throw new NotImplementedException(data.CodeElement.GetType().Name);
}
if (entry == null)
{
return(null);
}
if (entry.UserDefinedDataType == null)
{
return(new GeneratedDefinition(entry.DataType.Name, entry.DataType));
}
}
ITypedNode typed = symbol as ITypedNode;
if (typed == null)
{
return(null); // symbol untyped
}
if (data?.TypeDefinition != null)
{
return(data.TypeDefinition);
}
var types = node.SymbolTable.GetType(typed);
// return null if symbol type not found or ambiguous
return(types.Count != 1 ? null : types[0]);
}
public IList <TypeDefinition> GetType(ITypedNode symbol)
{
return(GetType(symbol.DataType));
}
private void WriteTypedNode(ITypedNode typedNode, StringBuilder result, bool edition, PrefixModules prefixModule,
bool allowObservable)
{
if (typedNode.IsDictionary)
{
result.Append("{ [key: string]: ");
}
WriteType(typedNode.Type, result, edition, prefixModule, allowObservable);
if (typedNode.IsCollection)
{
result.Append("[]");
}
if (typedNode.IsDictionary)
{
result.Append(" }");
}
}
/// <summary>
/// Gets a node's type as a string
/// </summary>
/// <param name="typedNode">The node to get the type of</param>
/// <returns>A string describing the type of the node</returns>
private static string GetTypeString(ITypedNode typedNode)
{
return($"Type: {(typedNode.Type is null ? "Type "+ typedNode.Position + " is not set or not found" : typedNode.Type.ToString())}");
}
public AssigmentStatement(VariableReference Reference, ITypedNode Assigment)
{
reference = Reference;
assigment = Assigment;
}
private void FillType(ITypedNode typedNode, Type parameterType, AssemblyNode assembly, Type[] parents, string version)
{
if (Nullable.GetUnderlyingType(parameterType) == null && parameterType.GetTypeInfo().IsGenericType)
{
if (parameterType.ImplementsInterface(typeof(IDictionary<,>)))
{
typedNode.IsDictionary = true;
parameterType = parameterType.GenericTypeArguments[1];
}
else if (parameterType.ImplementsInterface(typeof(IEnumerable<>)))
{
typedNode.IsCollection = true;
parameterType = parameterType.GenericTypeArguments[0];
}
}
if (parameterType.IsArray)
{
typedNode.IsCollection = true;
parameterType = parameterType.GetElementType();
}
typedNode.Type = ReadType(parameterType, assembly, parents, version);
}
