private EnumNode parseEnum()
{
var location = this.location;
expectToken(TokenType.Identifier, "enum");
string name = expectToken(TokenType.Identifier).Value;
EnumNode enum_ = new EnumNode(location, name);
expectToken(TokenType.OpenCurlyBrace);
int count = 0;
while (!acceptToken(TokenType.CloseCurlyBrace))
{
int num = count++;
string attrib = expectToken(TokenType.Identifier).Value;
if (acceptToken(TokenType.Assignment))
{
num = Convert.ToInt32(expectToken(TokenType.Integer).Value);
}
acceptToken(TokenType.Comma);
enum_.Attributes.Add(num, attrib);
}
return(enum_);
}
void ParseEnum(FileNode filenode, MessageNode msgNode)
{
var node = new EnumNode();
ParseCommentAndEOL(node);
// message的头注释
Consume(TokenType.Enum);
MarkLocation(node);
node.Name = FetchToken(TokenType.Identifier, "require enum type name").Value;
_tool.CheckDuplicate(node.Loc, filenode.Package, node.Name);
if (_fileNode.IsTopScope())
{
filenode.AddEnum(node);
}
else
{
msgNode.Add(node);
}
_fileNode.AddSymbol(filenode.Package, node.Name, node);
TryConsume(TokenType.EOL);
ParseCommentAndEOL(node);
Consume(TokenType.LBrace);
TryConsume(TokenType.EOL);
while (CurrToken.Type != TokenType.RBrace)
{
var valueNode = new EnumValueNode();
// 字段的头注释
ParseCommentAndEOL(valueNode);
MarkLocation(valueNode);
valueNode.Name = FetchToken(TokenType.Identifier, "require enum name").Value;
CheckDuplicate(node, _lexer.Loc, valueNode.Name);
Consume(TokenType.Assign);
valueNode.Number = FetchToken(TokenType.Number, "require enum value").ToInteger();
Consume(TokenType.SemiColon);
node.AddValue(valueNode);
// 尾注释
ParseTrailingComment(valueNode);
ParseCommentAndEOL(valueNode);
}
Consume(TokenType.RBrace); TryConsume(TokenType.EOL);
}
//────────────────────────────────────────
/// <summary>
///
/// </summary>
public Brush CreateBrush(EnumNode enumNode)
{
Brush result;
switch (enumNode)
{
case EnumNode.Scene:
//シーン用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 192, 0, 0));
break;
case EnumNode.Actor:
//アクター用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 179, 183, 0));
break;
case EnumNode.Thread:
//スレッド用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 64, 0, 164));
break;
case EnumNode.Comment:
result = new SolidBrush(Color.FromArgb(255, 192, 192, 192));
break;
case EnumNode.Error:
default:
result = new SolidBrush(Color.FromArgb(255, 212, 0, 0));
break;
}
return(result);
}
private long EvalEnum(EnumNode enode, PropNode prop)
{
long number = 0;
foreach (Symbol sym in prop.Default)
{
long n = 0;
var val = (sym as WeakSymbol).Identifier;
if (new Regex("^[-0-9]+$|^0x[-0-9a-fA-F]+$").IsMatch(val))
{
int bas = 10;
if (val.StartsWith("0x", StringComparison.Ordinal))
{
bas = 16;
val = val.Substring(2);
}
n = Convert.ToInt64(val, bas);
}
else
{
var otherNode = enode.childNodes.Single(o => o is PropNode && (o as PropNode).Name == val) as PropNode;
n = EvalEnum(enode, otherNode);
}
number = number | n;
}
return(number);
}
public void Visit(EnumNode node)
{
var values = string.Join(", ", node.Values);
IndentedAppendLine($"public enum {node.Name} {{{values}}}");
AppendLine();
}
//────────────────────────────────────────
/// <summary>
///
/// </summary>
public Pen CreatePen(EnumNode enumNode)
{
Pen result;
switch (enumNode)
{
case EnumNode.Scene:
//シーン用ペン。
result = new Pen(Color.FromArgb(255, 192, 0, 0));
break;
case EnumNode.Actor:
//アクター用ペン。
result = new Pen(Color.FromArgb(255, 179, 183, 0));
break;
case EnumNode.Thread:
//スレッド用ペン。
result = new Pen(Color.FromArgb(255, 64, 0, 164));
break;
case EnumNode.Comment:
result = new Pen(Color.FromArgb(255, 192, 192, 192));
break;
case EnumNode.Error:
default:
result = new Pen(Color.FromArgb(255, 212, 0, 0));
break;
}
return(result);
}
public FlirProperties(string spinnakerLibraryVersion, IManagedCamera camera)
{
SpinnakerLibraryVersion = spinnakerLibraryVersion;
PixelFormat = new EnumNode <PixelFormatEnums>(camera, nameof(camera.PixelFormat));
AcquisitionMode = new EnumNode <AcquisitionModeEnums>(camera, nameof(camera.AcquisitionMode));
TestPattern = new EnumNode <TestPatternEnums>(camera, nameof(camera.TestPattern));
TestPatternGeneratorSelector = new EnumNode <TestPatternGeneratorSelectorEnums>(camera, nameof(camera.TestPatternGeneratorSelector));
GainSelector = new EnumNode <GainSelectorEnums>(camera, nameof(camera.GainSelector));
GainAuto = new EnumNode <GainAutoEnums>(camera, nameof(camera.GainAuto));
AutoGainUpperLimit = new FloatNode(camera, "AutoGainUpperLimit"); //todo nameof
AutoGainLowerLimit = new FloatNode(camera, "AutoGainLowerLimit"); //todo nameof
Gain = new FloatNode(camera, nameof(camera.Gain));
ExposureMode = new EnumNode <ExposureModeEnums>(camera, nameof(camera.ExposureMode));
ExposureAuto = new EnumNode <ExposureAutoEnums>(camera, nameof(camera.ExposureAuto));
ExposureAutoUpperLimit = new FloatNode(camera, nameof(camera.AutoExposureExposureTimeUpperLimit));
ExposureAutoLowerLimit = new FloatNode(camera, nameof(camera.AutoExposureExposureTimeLowerLimit));
ExposureTime = new FloatNode(camera, nameof(camera.ExposureTime));
ExposureTimeAbs = new FloatNode(camera, "ExposureTimeAbs"); //todo abs
DeviceVendorName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceVendorName));
DeviceModelName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceModelName));
DeviceVersion = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceVersion));
DeviceSerialNumber = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceSerialNumber));
DeviceID = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceID));
DeviceUserID = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceUserID));
DeviceGenCpVersionMajor = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceGenCPVersionMajor));
DeviceGenCPVersionMinor = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceGenCPVersionMinor));
DeviceFamilyName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceFamilyName));
DeviceTemperatureSelector = new EnumNode <DeviceTemperatureSelectorEnums>(camera, nameof(camera.DeviceTemperatureSelector));
DeviceTemperature = new FloatNode(camera, nameof(camera.DeviceTemperature));
Width = new IntegerNode(camera, nameof(camera.Width));
Height = new IntegerNode(camera, nameof(camera.Height));
FPS = new FloatNode(camera, nameof(camera.AcquisitionFrameRate));
}
public AstNode VisitEnum(EnumNode n)
{
if (!n.Attributes.IsNullOrEmpty())
{
foreach (var a in n.Attributes)
{
Visit(a);
}
AppendLineAndIndent();
}
if (n.AccessModifier != null)
{
Visit(n.AccessModifier);
Append(" ");
}
Append("enum ");
Visit(n.Name);
Append("{");
IncreaseIndent();
AppendLineAndIndent();
if (n.Members.Count > 0)
{
Visit(n.Members[0]);
foreach (var m in n.Members.Skip(1))
{
AppendLineAndIndent(",");
Visit(m);
}
}
DecreaseIndent();
AppendLineAndIndent();
Append("}");
return(n);
}
/*assignment-options:
| optional-assignable-identifiers-list-p
| '=' expression optional-assignable-identifiers-list-p
| EPSILON */
private List <EnumNode> assignment_options(IdNode currentId, int counter)
{
printIfDebug("assignment_options");
var enumToken = token;
if (pass(TokenType.PUNT_COMMA))
{
var newEntryEnum = new EnumNode(currentId, new LiteralIntNode(counter, enumToken), currentId.token);
return(optional_assignable_identifiers_list_p(newEntryEnum, counter + 1));
}
else if (pass(TokenType.OP_ASSIGN))
{
consumeToken();
ExpressionNode exp = expression();
if (exp is InlineExpressionNode)
{
exp = ((InlineExpressionNode)exp).primary;
if (exp is LiteralIntNode)
{
counter = ((LiteralIntNode)exp).Value;
}
}
var assignExpr = new EnumNode(currentId, exp, currentId.token);
// var nextVal = new SumNode(exp,new LiteralIntNode(1)); //TODO: evaluate and send as parameter
return(optional_assignable_identifiers_list_p(assignExpr, counter + 1));
}
else
{
var newListEnumerables = new List <EnumNode>();
var newEntryEnum = new EnumNode(currentId, new LiteralIntNode(counter, enumToken), currentId.token);
newListEnumerables.Add(newEntryEnum);
return(newListEnumerables);
}
}
public BaseNode AddEnum(string id, string name, string file)
{
EnumNode enumn = new EnumNode(id, name, file);
nodemap.Add(id, enumn);
return(enumn);
}
public EnumMemberNodeWithSymbols(
EnumMemberDeclarationSyntax declaration,
EnumNode container,
SemanticModel semanticModel)
: base(declaration, container)
{
this.semanticModel = semanticModel;
}
public void VisitEnum(EnumNode node)
{
_visitor.VisitTopLevelStatement(node);
foreach (EnumDeclarationNode declaration in node.Declarations)
{
declaration.AcceptSyntaxTreeVisitor(_childrenVisitor);
}
}
public virtual AstNode VisitEnum(EnumNode n)
{
Visit(n.Attributes);
Visit(n.AccessModifier);
Visit(n.Name);
Visit(n.Members);
return(n);
}
protected void WalkEnumNode(EnumNode node)
{
if (node == null)
{
return;
}
node.Options?.ForEach(o => VisitEnumOption(o));
}
public void EnumNode_ThrowsNotImplementedException_AccessKind()
{
// Arrange
Mock<IEdmEnumTypeReference> type = new Mock<IEdmEnumTypeReference>();
Mock<IEdmEnumValue> value = new Mock<IEdmEnumValue>();
EnumNode enumNode = new EnumNode(type.Object, value.Object);
// Act & Assert
Assert.Throws<NotImplementedException>(() => enumNode.Kind, "The method or operation is not implemented.");
}
void ProcessEnum(TypeDefinition type)
{
var typeName = type.PackageName();
var result = new EnumNode(typeName);
foreach (var field in type.Fields.Where(f => f.HasConstant))
{
result.Entries.Add(Tuple.Create(field.Name, (int)field.Constant));
}
AddPackageNode(typeName.Package, result);
}
private void EmitEnumStringer(EnumNode enode, StringBuilder sb)
{
sb.AppendLine("var " + enode.Name + "_name = map[" + enode.Name + "]string{");
// duplicate elements don't really make sense here, so we filter them
var uniqueNodes = new List <PropNode>();
{
var allValues = new List <long>();
foreach (var node in enode.childNodes)
{
if (!(node is PropNode))
{
continue;
}
var prop = node as PropNode;
long val = EvalEnum(enode, prop);
if (allValues.Contains(val))
{
continue;
}
allValues.Add(val);
uniqueNodes.Add(prop);
}
}
foreach (PropNode prop in uniqueNodes)
{
sb.Append(" " + EvalEnum(enode, prop) + ": ");
sb.AppendLine("\"" + enode.Name + "_" + prop.Name + "\",");
}
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("func (e " + enode.Name + ") String() string {");
sb.AppendLine(" if s, ok := " + enode.Name + "_name[e]; ok {");
sb.AppendLine(" return s");
sb.AppendLine(" }");
sb.AppendLine(" var flags []string");
sb.AppendLine(" for k, v := range " + enode.Name + "_name {");
sb.AppendLine(" if e&k != 0 {");
sb.AppendLine(" flags = append(flags, v)");
sb.AppendLine(" }");
sb.AppendLine(" }");
sb.AppendLine(" if len(flags) == 0 {");
sb.AppendLine(" return fmt.Sprint(e)");
sb.AppendLine(" }");
sb.AppendLine(" sort.Strings(flags)");
sb.AppendLine(" return strings.Join(flags, \" | \")");
sb.AppendLine("}");
sb.AppendLine();
}
private void EmitEnumNode(EnumNode enode, StringBuilder sb)
{
string type = enode.Type != null?EmitType(enode.Type) : "int32";
enumTypes.Add(enode.Name, type);
sb.AppendLine("type " + enode.Name + " " + type);
sb.AppendLine();
sb.AppendLine("const (");
bool first = true;
foreach (PropNode prop in enode.childNodes)
{
// the first element in the enum must be prefixed by its type
string t = first ? " " + enode.Name : "";
string val = String.Join(" | ", prop.Default.Select(item => {
var name = EmitSymbol(item);
// if this is an element of this enum, make sure to prefix it with its name
return((enode.childNodes.Exists(node => node.Name == name) ? enode.Name + "_" : "") + name);
}));
sb.Append(" " + enode.Name + "_" + prop.Name + t + " = " + val);
if (prop.Obsolete != null)
{
if (prop.Obsolete.Length > 0)
{
sb.Append(" // Deprecated: " + prop.Obsolete);
}
else
{
sb.Append(" // Deprecated");
}
}
sb.AppendLine();
if (first)
{
first = false;
}
}
sb.AppendLine(")");
sb.AppendLine();
if (debug)
{
EmitEnumStringer(enode, sb);
}
}
public override EnumNode VisitEnumNode(EnumNode enumNode)
{
if (enumNode == null || enumNode.SourceContext.SourceText == null)
{
return(null);
}
this.writer.WriteStartElement("Enum");
this.writer.WriteAttributeString("name", enumNode.Name.Name);
this.WriteSourceContext(enumNode);
this.writer.WriteEndElement(); // Enum
return(enumNode);
}
private void BeforeExpand(TreeNode parentNode, CodeEnum codeEnum)
{
EnumNode cn = new EnumNode(codeEnum, this);
if (codeEnum.Members.Count > 0)
{
AddNodeWithChilds(parentNode.Nodes, cn);
}
else
{
parentNode.Nodes.Add(cn);
}
}
/// <summary>
/// Override this method for the enum node.
/// </summary>
/// <remarks>
/// This method is intended to be called from method overrides in subclasses.
/// This method also supports unit-testing scenarios and is not intended to be called from user code.
/// Call the Validate method to validate a <see cref="FilterQueryOption"/> instance.
/// </remarks>
/// <param name="enumNode"></param>
/// <param name="settings"></param>
public virtual void ValidateEnumNode(EnumNode enumNode, ODataValidationSettings settings)
{
if (enumNode == null)
{
throw Error.ArgumentNull("enumNode");
}
if (settings == null)
{
throw Error.ArgumentNull("settings");
}
// no default validation logic here
}
public void Accept(EnumNode node)
{
// Enums are PascalCase
HassiumWarning.EnforceCasing(module, node.SourceLocation, node.Name, HassiumCasingType.Pascal);
HassiumEnum enum_ = new HassiumEnum(node.Name);
enum_.IsPrivate = node.IsPrivate;
foreach (var pair in node.Attributes)
{
enum_.AddAttribute(pair.Value, new HassiumInt(pair.Key));
}
classStack.Peek().AddAttribute(enum_.Name, enum_);
}
/*optional-assignable-identifiers-list-p:
| ',' optional-assignable-identifiers-list
| EPSILON */
private List <EnumNode> optional_assignable_identifiers_list_p(EnumNode newEntryEnum, int counter)
{
printIfDebug("optional_assignable_identifiers_list_p");
if (pass(TokenType.PUNT_COMMA))
{
consumeToken();
var listEntries = optional_assignable_identifiers_list(counter);
listEntries.Insert(0, newEntryEnum);
return(listEntries);
}
else
{
var newListEnumerables = new List <EnumNode>();
newListEnumerables.Add(newEntryEnum);
return(newListEnumerables);
}
}
public void Dump(BaseNode root)
{
if (root == null)
{
root = rootNode;
}
foreach (BaseNode node in root.childnodes)
{
if (node.Type() == typeof(EnumNode))
{
EnumNode enode = node as EnumNode;
Console.WriteLine("Enum: " + enode.name);
}
else if (node.Type() == typeof(StructNode))
{
StructNode snode = node as StructNode;
Console.WriteLine("Struct: " + snode.name);
}
else if (node.Type() == typeof(UnionNode))
{
UnionNode unode = node as UnionNode;
Console.WriteLine("Union: " + unode.name);
}
else if (node.Type() == typeof(ClassNode))
{
ClassNode cnode = node as ClassNode;
Console.WriteLine("Class: " + cnode.name);
}
else if (node.Type() == typeof(FieldNode))
{
FieldNode fnode = node as FieldNode;
BaseNode n;
Console.WriteLine("Field: " + fnode.name + " type: " + ResolveType(fnode.type, out n, false) + " (" + fnode.type + ")");
}
else if (node.Type() == typeof(MethodNode))
{
MethodNode mnode = node as MethodNode;
BaseNode n;
Console.WriteLine("Method: " + mnode.name + " virtual: " + mnode.virt + " returns: " + ResolveType(mnode.ret, out n, true) + " (" + mnode.ret + ")");
}
Dump(node);
}
}
void AssignmentOptions(ref List <EnumNode> identifier, ref EnumNode actual)
{
printDebug("Assignment Options");
if (!Match(TokenType.OP_ASSIGN))
{
OptionalAssignableIdentifiersListPrime(ref identifier);
}
else
{
MatchExactly(new TokenType[] { TokenType.OP_ASSIGN });
if (!Match(TokenType.LITERAL_INT))
{
ThrowSyntaxException("Int Literal expected.");
}
actual.assignment = int.Parse(this.ConsumeToken().lexema);
OptionalAssignableIdentifiersListPrime(ref identifier);
}
}
protected override void VisitEnumNode(EnumNode node)
{
AppendIndentation();
AppendAccesType(node.Visibility);
Append("enum ");
Append(node.Name);
AppendLineEnding();
AppendLine("{");
++_indentation;
base.VisitEnumNode(node);
--_indentation;
AppendLine("}");
AppendLineEnding();
}
private void EmitEnumStringer(EnumNode enode, StringBuilder sb)
{
sb.AppendLine("var " + enode.Name + "_name = map[" + enode.Name + "]string{");
// duplicate elements don't really make sense here, so we filter them
var uniqueNodes = new List <PropNode>();
{
var allValues = new List <long>();
foreach (var node in enode.childNodes)
{
if (!(node is PropNode))
{
continue;
}
var prop = node as PropNode;
long val = EvalEnum(enode, prop);
if (allValues.Contains(val))
{
continue;
}
allValues.Add(val);
uniqueNodes.Add(prop);
}
}
foreach (PropNode prop in uniqueNodes)
{
sb.Append(" " + EvalEnum(enode, prop) + ": ");
sb.AppendLine("\"" + enode.Name + "_" + prop.Name + "\",");
}
sb.AppendLine("}");
sb.AppendLine();
sb.AppendLine("func (e " + enode.Name + ") String() string {");
sb.AppendLine(" if s, ok := " + enode.Name + "_name[e]; ok {");
sb.AppendLine(" return s");
sb.AppendLine(" }");
sb.AppendLine(" return \"INVALID\"");
sb.AppendLine("}");
sb.AppendLine();
}
void OptionalAssignableIdentifiersList(ref List <EnumNode> identifiers)
{
printDebug("Optional Assignable Identifiers List");
if (Match(TokenType.ID))
{
var token = MatchExactly(TokenType.ID);
var enum_node = new EnumNode();
AssignmentOptions(ref identifiers, ref enum_node);
enum_node.identifier = new IdentifierNode(token);
identifiers.Insert(0, enum_node);
}
else
{
//EPSILON
}
}
public void ChunkNodesHaveEnums()
{
var enums = new List <EnumDeclarationNode>();
for (var i = 0; i < 5; i++)
{
var @enum = new EnumNode(SourcePosition.NIL);
@enum.AddElement("reee");
enums.Add(new EnumDeclarationNode(SourcePosition.NIL, @enum, "yeeee", true));
}
foreach (var @enumDeclaration in enums)
{
subject.Enums.Add(@enumDeclaration);
}
for (var i = 0; i < subject.Enums.Count; i++)
{
Assert.AreEqual(subject.Enums[i], @enums[i]);
}
}
private void EmitEnumStringer(EnumNode enode, StringBuilder sb)
{
sb.AppendLine("func (e " + enode.Name + ") String() string {");
sb.AppendLine(" switch e {");
// go does not allow duplicate cases, so we filter duplicte ones out
var uniqueNodes = new List <PropNode>();
{
var allValues = new List <long>();
for (int i = 0; i < enode.childNodes.Count; i++)
{
Node node = enode.childNodes[i];
if (!(node is PropNode))
{
continue;
}
PropNode prop = node as PropNode;
long val = EvalEnum(enode, prop);
if (allValues.Contains(val))
{
continue;
}
allValues.Add(val);
uniqueNodes.Add(prop);
}
}
foreach (PropNode prop in uniqueNodes)
{
sb.AppendLine(" case " + enode.Name + "_" + prop.Name + ":");
sb.AppendLine(" return \"" + enode.Name + "_" + prop.Name + "\"");
}
sb.AppendLine(" default:");
sb.AppendLine(" return \"INVALID\"");
sb.AppendLine(" }");
sb.AppendLine("}");
sb.AppendLine();
}
public void VisitEnum(EnumNode node)
{
UpdateLine(node);
asm.NewObject();
var elements = node.Elements.ToArray();
for (var i = 0; i < elements.Length; i++)
{
asm.Dup();
asm.PushConstant(NeoString.ValueOf(elements[i]));
asm.PushConstant(NeoInt.ValueOf(i));
asm.Set();
asm.Dup();
asm.PushConstant(NeoInt.ValueOf(i));
asm.PushConstant(NeoString.ValueOf(elements[i]));
asm.Set();
}
asm.Frozen();
}
private static EnumNode/*!*/ GetCustomAttributeEnumNode(ref TypeNode/*!*/ type)
{
EnumNode etype = ((TypeNode)type) as EnumNode;
if (etype == null || etype.UnderlyingType == null)
{
//Happens when type is declared in a assembly that has not been resolved. In that case only the type name
//and the fact that it is a value type is known. There is no completely safe recovery from it, but at this point we
//can fake up an enum with Int32 as underlying type. This works in most situations.
etype = new EnumNode();
etype.Name = type.Name;
etype.Namespace = type.Namespace;
etype.DeclaringModule = type.DeclaringModule;
etype.UnderlyingType = CoreSystemTypes.Int32;
type = etype;
}
return etype;
}
private TypeNode/*!*/ ConstructCorrectTypeNodeSubclass(int i, Identifier/*!*/ namesp, int firstInterfaceIndex, int lastInterfaceIndex,
TypeFlags flags, InterfaceList interfaces, int baseTypeCodedIndex, bool isSystemEnum)
{
TypeNode result;
TypeNode.TypeAttributeProvider attributeProvider = new TypeNode.TypeAttributeProvider(this.GetTypeAttributes);
TypeNode.NestedTypeProvider nestedTypeProvider = new TypeNode.NestedTypeProvider(this.GetNestedTypes);
TypeNode.TypeMemberProvider memberProvider = new TypeNode.TypeMemberProvider(this.GetTypeMembers);
bool isTemplateParameter = false;
if ((flags & TypeFlags.Interface) != 0)
{
if (isTemplateParameter)
result = new TypeParameter(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
else
result = new Interface(interfaces, nestedTypeProvider, attributeProvider, memberProvider, i);
}
else if (isTemplateParameter)
{
result = new ClassParameter(nestedTypeProvider, attributeProvider, memberProvider, i);
}
else
{
result = null;
TypeNode baseClass = this.GetTypeIfNotGenericInstance(baseTypeCodedIndex);
if (baseClass != null)
{
if (baseClass == CoreSystemTypes.MulticastDelegate) //TODO: handle single cast delegates
result = new DelegateNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.Enum)
result = new EnumNode(nestedTypeProvider, attributeProvider, memberProvider, i);
else if (baseClass == CoreSystemTypes.ValueType &&
!(isSystemEnum && (flags & TypeFlags.Sealed) == 0))
{
result = new Struct(nestedTypeProvider, attributeProvider, memberProvider, i);
}
}
if(result == null)
result = new Class(nestedTypeProvider, attributeProvider, memberProvider, i);
}
result.Flags = flags;
result.Interfaces = interfaces;
return result;
}
private static void ClearStatics(){
//Special base types
Object = null;
String = null;
ValueType = null;
Enum = null;
MulticastDelegate = null;
Array = null;
Type = null;
#if !MinimalReader
Delegate = null;
Exception = null;
Attribute = null;
#endif
//primitive types
Boolean = null;
Char = null;
Int8 = null;
UInt8 = null;
Int16 = null;
UInt16 = null;
Int32 = null;
UInt32 = null;
Int64 = null;
UInt64 = null;
Single = null;
Double = null;
IntPtr = null;
UIntPtr = null;
DynamicallyTypedReference = null;
//Special types
#if !MinimalReader
DBNull = null;
DateTime = null;
Decimal = null;
RuntimeArgumentHandle = null;
#endif
ArgIterator = null;
RuntimeFieldHandle = null;
RuntimeMethodHandle = null;
RuntimeTypeHandle = null;
IsVolatile = null;
Void = null;
SecurityAction = null;
}
public virtual EnumNode VisitEnumNode(EnumNode enumNode, EnumNode changes, EnumNode deletions, EnumNode insertions){
if (enumNode == null) return changes;
TypeNode result = this.VisitTypeNode(enumNode, changes, deletions, insertions);
Debug.Assert(result is EnumNode);
if (result == enumNode){
Debug.Assert(changes != null);
if (changes != null)
enumNode.UnderlyingType = this.VisitTypeReference(enumNode.UnderlyingType, changes.UnderlyingType);
return enumNode;
}
return result as EnumNode;
}
public override EnumNode VisitEnumNode(EnumNode enumNode){
if (enumNode == null) return null;
if (enumNode.UnderlyingTypeExpression != null)
enumNode.UnderlyingType = this.VisitTypeReference(enumNode.UnderlyingTypeExpression);
else
enumNode.UnderlyingType = this.VisitTypeReference(enumNode.UnderlyingType);
return base.VisitEnumNode(enumNode);
}
//────────────────────────────────────────
public DecorationImpl(EnumNode node, EnumShape shape)
{
this.Node = node;
this.Shape = shape;
this.Name = "";
}
/// <summary>
/// ノード名。またはコメント。
/// </summary>
/// <param name="node"></param>
/// <param name="name"></param>
public DecorationImpl(EnumNode node, string name)
{
this.Node = node;
this.Shape = EnumShape.Name;
this.Name = name;
}
private static void ClearStatics(){
AttributeUsageAttribute = null;
ConditionalAttribute = null;
DefaultMemberAttribute = null;
InternalsVisibleToAttribute = null;
ObsoleteAttribute = null;
GenericICollection = null;
GenericIEnumerable = null;
GenericIList = null;
ICloneable = null;
ICollection = null;
IEnumerable = null;
IList = null;
#if !MinimalReader
//Special attributes
AllowPartiallyTrustedCallersAttribute = null;
AssemblyCompanyAttribute = null;
AssemblyConfigurationAttribute = null;
AssemblyCopyrightAttribute = null;
AssemblyCultureAttribute = null;
AssemblyDelaySignAttribute = null;
AssemblyDescriptionAttribute = null;
AssemblyFileVersionAttribute = null;
AssemblyFlagsAttribute = null;
AssemblyInformationalVersionAttribute = null;
AssemblyKeyFileAttribute = null;
AssemblyKeyNameAttribute = null;
AssemblyProductAttribute = null;
AssemblyTitleAttribute = null;
AssemblyTrademarkAttribute = null;
AssemblyVersionAttribute = null;
ClassInterfaceAttribute = null;
CLSCompliantAttribute = null;
ComImportAttribute = null;
ComRegisterFunctionAttribute = null;
ComSourceInterfacesAttribute = null;
ComUnregisterFunctionAttribute = null;
ComVisibleAttribute = null;
DebuggableAttribute = null;
DebuggerHiddenAttribute = null;
DebuggerStepThroughAttribute = null;
DebuggingModes = null;
DllImportAttribute = null;
FieldOffsetAttribute = null;
FlagsAttribute = null;
GuidAttribute = null;
ImportedFromTypeLibAttribute = null;
InAttribute = null;
IndexerNameAttribute = null;
InterfaceTypeAttribute = null;
MethodImplAttribute = null;
NonSerializedAttribute = null;
OptionalAttribute = null;
OutAttribute = null;
ParamArrayAttribute = null;
RuntimeCompatibilityAttribute = null;
SatelliteContractVersionAttribute = null;
SerializableAttribute = null;
SecurityAttribute = null;
SecurityCriticalAttribute = null;
SecurityTransparentAttribute = null;
SecurityTreatAsSafeAttribute = null;
STAThreadAttribute = null;
StructLayoutAttribute = null;
SuppressMessageAttribute = null;
SuppressUnmanagedCodeSecurityAttribute = null;
SecurityAction = null;
//Classes need for System.TypeCode
DBNull = null;
DateTime = null;
TimeSpan = null;
//Classes and interfaces used by the Framework
Activator = null;
AppDomain = null;
ApplicationException = null;
ArgumentException = null;
ArgumentNullException = null;
ArgumentOutOfRangeException = null;
ArrayList = null;
AsyncCallback = null;
Assembly = null;
CodeAccessPermission = null;
CollectionBase = null;
CultureInfo = null;
DictionaryBase = null;
DictionaryEntry = null;
DuplicateWaitObjectException = null;
Environment = null;
EventArgs = null;
ExecutionEngineException = null;
GenericArraySegment = null;
#if !WHIDBEYwithGenerics
GenericArrayToIEnumerableAdapter = null;
#endif
GenericDictionary = null;
GenericIComparable = null;
GenericIComparer = null;
GenericIDictionary = null;
GenericIEnumerator = null;
GenericKeyValuePair = null;
GenericList = null;
GenericNullable = null;
GenericQueue = null;
GenericSortedDictionary = null;
GenericStack = null;
GC = null;
Guid = null;
__HandleProtector = null;
HandleRef = null;
Hashtable = null;
IASyncResult = null;
IComparable = null;
IDictionary = null;
IComparer = null;
IDisposable = null;
IEnumerator = null;
IFormatProvider = null;
IHashCodeProvider = null;
IMembershipCondition = null;
IndexOutOfRangeException = null;
InvalidCastException = null;
InvalidOperationException = null;
IPermission = null;
ISerializable = null;
IStackWalk = null;
Marshal = null;
MarshalByRefObject = null;
MemberInfo = null;
NativeOverlapped = null;
Monitor = null;
NotSupportedException = null;
NullReferenceException = null;
OutOfMemoryException = null;
ParameterInfo = null;
Queue = null;
ReadOnlyCollectionBase = null;
ResourceManager = null;
ResourceSet = null;
SerializationInfo = null;
Stack = null;
StackOverflowException = null;
Stream = null;
StreamingContext = null;
StringBuilder = null;
StringComparer = null;
StringComparison = null;
SystemException = null;
Thread = null;
WindowsImpersonationContext = null;
#endif
#if ExtendedRuntime
AnonymousAttribute = null;
AnonymityEnum = null;
ComposerAttribute = null;
CustomVisitorAttribute = null;
TemplateAttribute = null;
TemplateInstanceAttribute = null;
UnmanagedStructTemplateParameterAttribute = null;
TemplateParameterFlagsAttribute = null;
GenericBoxed = null;
GenericIEnumerableToGenericIListAdapter = null;
GenericInvariant = null;
GenericNonEmptyIEnumerable = null;
GenericNonNull = null;
GenericStreamUtility = null;
GenericUnboxer = null;
ElementTypeAttribute = null;
IDbTransactable = null;
IAggregate = null;
IAggregateGroup = null;
StreamNotSingletonException = null;
SqlHint = null;
SqlFunctions = null;
XmlAttributeAttributeClass = null;
XmlChoiceIdentifierAttributeClass = null;
XmlElementAttributeClass = null;
XmlIgnoreAttributeClass = null;
XmlTypeAttributeClass = null;
INullable = null;
SqlBinary = null;
SqlBoolean = null;
SqlByte = null;
SqlDateTime = null;
SqlDecimal = null;
SqlDouble = null;
SqlGuid = null;
SqlInt16 = null;
SqlInt32 = null;
SqlInt64 = null;
SqlMoney = null;
SqlSingle = null;
SqlString = null;
IDbConnection = null;
IDbTransaction = null;
IsolationLevel = null;
//OrdinaryExceptions
NoChoiceException = null;
IllegalUpcastException = null;
//NonNull
Range = null;
//Invariants
InitGuardSetsDelegate = null;
CheckInvariantDelegate = null;
ObjectInvariantException = null;
ThreadConditionDelegate = null;
GuardThreadStart = null;
Guard = null;
ContractMarkers = null;
//IReduction = null;
AssertHelpers = null;
ThreadStart = null;
//CheckedExceptions
ICheckedException = null;
CheckedException = null;
// Contracts
UnreachableException = null;
ContractException = null;
NullTypeException = null;
AssertException = null;
AssumeException = null;
InvalidContractException = null;
RequiresException = null;
EnsuresException = null;
ModifiesException = null;
ThrowsException = null;
DoesException = null;
InvariantException = null;
ContractMarkerException = null;
PreAllocatedExceptions = null;
AdditiveAttribute = null;
InsideAttribute = null;
SpecPublicAttribute = null;
SpecProtectedAttribute = null;
SpecInternalAttribute = null;
PureAttribute = null;
OwnedAttribute = null;
RepAttribute = null;
PeerAttribute = null;
CapturedAttribute = null;
LockProtectedAttribute = null;
RequiresLockProtectedAttribute = null;
ImmutableAttribute = null;
RequiresImmutableAttribute = null;
RequiresCanWriteAttribute = null;
StateIndependentAttribute = null;
ConfinedAttribute = null;
ModelfieldContractAttribute = null;
ModelfieldAttribute = null;
SatisfiesAttribute = null;
ModelfieldException = null;
/* Diego's Attributes for Purity Analysis and Write effects */
OnceAttribute = null;
WriteConfinedAttribute = null;
WriteAttribute = null;
ReadAttribute = null;
GlobalReadAttribute = null;
GlobalWriteAttribute = null;
GlobalAccessAttribute = null;
FreshAttribute = null;
EscapesAttribute = null;
/* */
ModelAttribute = null;
RequiresAttribute = null;
EnsuresAttribute = null;
ModifiesAttribute = null;
HasWitnessAttribute = null;
WitnessAttribute = null;
InferredReturnValueAttribute = null;
ThrowsAttribute = null;
DoesAttribute = null;
InvariantAttribute = null;
NoDefaultActivityAttribute = null;
NoDefaultContractAttribute = null;
ReaderAttribute = null;
ShadowsAssemblyAttribute = null;
VerifyAttribute = null;
DependentAttribute = null;
ElementsRepAttribute = null;
ElementsPeerAttribute = null;
ElementAttribute = null;
ElementCollectionAttribute = null;
RecursionTerminationAttribute = null;
NoReferenceComparisonAttribute = null;
ResultNotNewlyAllocatedAttribute = null;
noHeapAllocationAttribute = null;
#endif
}
public virtual void VisitEnumNode(EnumNode enumNode)
{
this.VisitTypeNode(enumNode);
}
public override EnumNode VisitEnumNode(EnumNode enumNode)
{
throw new ApplicationException("unimplemented");
}
public static void Initialize(bool doNotLockFile, bool getDebugInfo){
if (CoreSystemTypes.Initialized) CoreSystemTypes.Clear();
if (SystemAssembly == null)
SystemAssembly = CoreSystemTypes.GetSystemAssembly(doNotLockFile, getDebugInfo);
if (SystemAssembly == null) throw new InvalidOperationException(ExceptionStrings.InternalCompilerError);
if (TargetPlatform.TargetVersion == null){
TargetPlatform.TargetVersion = SystemAssembly.Version;
if (TargetPlatform.TargetVersion == null)
TargetPlatform.TargetVersion = typeof(object).Module.Assembly.GetName().Version;
}
if (TargetPlatform.TargetVersion != null){
if (TargetPlatform.TargetVersion.Major > 1 || TargetPlatform.TargetVersion.Minor > 1 ||
(TargetPlatform.TargetVersion.Minor == 1 && TargetPlatform.TargetVersion.Build == 9999)){
if (SystemAssembly.IsValidTypeName(StandardIds.System, Identifier.For("Nullable`1")))
TargetPlatform.GenericTypeNamesMangleChar = '`';
else if (SystemAssembly.IsValidTypeName(StandardIds.System, Identifier.For("Nullable!1")))
TargetPlatform.GenericTypeNamesMangleChar = '!';
else if (TargetPlatform.TargetVersion.Major == 1 && TargetPlatform.TargetVersion.Minor == 2)
TargetPlatform.GenericTypeNamesMangleChar = (char)0;
}
}
// This must be done in the order: Object, ValueType, Char, String
// or else some of the generic type instantiations don't get filled
// in correctly. (String ends up implementing IEnumerable<string>
// instead of IEnumerable<char>.)
Object = (Class)GetTypeNodeFor("System", "Object", ElementType.Object);
ValueType = (Class)GetTypeNodeFor("System", "ValueType", ElementType.Class);
Char = (Struct)GetTypeNodeFor("System", "Char", ElementType.Char);
String = (Class)GetTypeNodeFor("System", "String", ElementType.String);
Enum = (Class)GetTypeNodeFor("System", "Enum", ElementType.Class);
MulticastDelegate = (Class)GetTypeNodeFor("System", "MulticastDelegate", ElementType.Class);
Array = (Class)GetTypeNodeFor("System", "Array", ElementType.Class);
Type = (Class)GetTypeNodeFor("System", "Type", ElementType.Class);
Boolean = (Struct)GetTypeNodeFor("System", "Boolean", ElementType.Boolean);
Int8 = (Struct)GetTypeNodeFor("System", "SByte", ElementType.Int8);
UInt8 = (Struct)GetTypeNodeFor("System", "Byte", ElementType.UInt8);
Int16 = (Struct)GetTypeNodeFor("System", "Int16", ElementType.Int16);
UInt16 = (Struct)GetTypeNodeFor("System", "UInt16", ElementType.UInt16);
Int32 = (Struct)GetTypeNodeFor("System", "Int32", ElementType.Int32);
UInt32 = (Struct)GetTypeNodeFor("System", "UInt32", ElementType.UInt32);
Int64 = (Struct)GetTypeNodeFor("System", "Int64", ElementType.Int64);
UInt64 = (Struct)GetTypeNodeFor("System", "UInt64", ElementType.UInt64);
Single = (Struct)GetTypeNodeFor("System", "Single", ElementType.Single);
Double = (Struct)GetTypeNodeFor("System", "Double", ElementType.Double);
IntPtr = (Struct)GetTypeNodeFor("System", "IntPtr", ElementType.IntPtr);
UIntPtr = (Struct)GetTypeNodeFor("System", "UIntPtr", ElementType.UIntPtr);
DynamicallyTypedReference = (Struct)GetTypeNodeFor("System", "TypedReference", ElementType.DynamicallyTypedReference);
#if !MinimalReader
Delegate = (Class)GetTypeNodeFor("System", "Delegate", ElementType.Class);
Exception = (Class)GetTypeNodeFor("System", "Exception", ElementType.Class);
Attribute = (Class)GetTypeNodeFor("System", "Attribute", ElementType.Class);
DBNull = (Class)GetTypeNodeFor("System", "DBNull", ElementType.Class);
DateTime = (Struct)GetTypeNodeFor("System", "DateTime", ElementType.ValueType);
Decimal = (Struct)GetTypeNodeFor("System", "Decimal", ElementType.ValueType);
#endif
ArgIterator = (Struct)GetTypeNodeFor("System", "ArgIterator", ElementType.ValueType);
IsVolatile = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "IsVolatile", ElementType.Class);
Void = (Struct)GetTypeNodeFor("System", "Void", ElementType.Void);
RuntimeFieldHandle = (Struct)GetTypeNodeFor("System", "RuntimeFieldHandle", ElementType.ValueType);
RuntimeMethodHandle = (Struct)GetTypeNodeFor("System", "RuntimeMethodHandle", ElementType.ValueType);
RuntimeTypeHandle = (Struct)GetTypeNodeFor("System", "RuntimeTypeHandle", ElementType.ValueType);
#if !MinimalReader
RuntimeArgumentHandle = (Struct)GetTypeNodeFor("System", "RuntimeArgumentHandle", ElementType.ValueType);
#endif
SecurityAction = GetTypeNodeFor("System.Security.Permissions", "SecurityAction", ElementType.ValueType) as EnumNode;
CoreSystemTypes.Initialized = true;
CoreSystemTypes.InstantiateGenericInterfaces();
#if !NoWriter
Literal.Initialize();
#endif
object dummy = TargetPlatform.AssemblyReferenceFor; //Force selection of target platform
if (dummy == null) return;
}
private void DoConvert()
{
var oldGraph = target as IGraphData;
IGraphData graphData = null;
var graph = ScriptableObject.CreateInstance<UnityGraphData>();
if (oldGraph is ExternalStateMachineGraph)
{
graph.Graph = new StateMachineGraph();
}
else if (oldGraph is ExternalSubsystemGraph)
{
graph.Graph = new StateMachineGraph();
}
else
{
graph.Graph = new MVVMGraph();
}
graphData = graph;
graph.name = oldGraph.Name;
graph.Identifier = oldGraph.Identifier;
graph.Graph.Identifier = oldGraph.Identifier;
// Convert all the nodes
Dictionary<DiagramNode, DiagramNode> converted = new Dictionary<DiagramNode, DiagramNode>();
List<ConnectionData> connections = new List<ConnectionData>();
foreach (var oldNode in oldGraph.NodeItems.OfType<SceneManagerData>())
{
var node = new SceneTypeNode
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
//foreach (var item in oldNode.Transitions)
//{
// node.ChildItems.Add(new SceneTransitionsReference()
// {
// Node = node,
// Identifier = item.Identifier,
// SourceIdentifier = item.CommandIdentifier,
// });
// if (string.IsNullOrEmpty(item.ToIdentifier)) continue;
// connections.Add(new ConnectionData(item.Identifier, item.ToIdentifier));
//}
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<SubSystemData>())
{
var node = new SubsystemNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<ComputedPropertyData>())
{
var node = new ComputedPropertyNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name,
PropertyType = oldNode.RelatedType
};
foreach (var item in oldNode.DependantProperties)
{
connections.Add(new ConnectionData(item.Identifier, node.Identifier));
}
foreach (var x in oldNode.DependantNodes)
{
foreach (var item in x.AllProperties)
{
if (x[item.Identifier])
{
node.ChildItems.Add(new SubPropertiesReference()
{
SourceIdentifier = item.Identifier,
Node = node,
});
}
}
}
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<ElementData>())
{
var node = new ElementNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name,
};
if (!string.IsNullOrEmpty(oldNode.BaseIdentifier))
{
connections.Add(new ConnectionData(oldNode.BaseIdentifier, oldNode.Identifier));
}
foreach (var item in oldNode.Properties)
{
node.ChildItems.Add(new PropertiesChildItem()
{
Identifier = item.Identifier,
Node = node,
Name = item.Name,
RelatedType = item.RelatedType
});
}
foreach (var item in oldNode.Collections)
{
node.ChildItems.Add(new CollectionsChildItem()
{
Identifier = item.Identifier,
Name = item.Name,
Node = node,
RelatedType = item.RelatedType
});
}
foreach (var item in oldNode.Commands)
{
node.ChildItems.Add(new CommandsChildItem()
{
Identifier = item.Identifier,
Name = item.Name,
Node = node,
RelatedType = item.RelatedType
});
if (!string.IsNullOrEmpty(item.TransitionToIdentifier))
connections.Add(new ConnectionData(item.Identifier, item.TransitionToIdentifier));
}
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<ClassNodeData>())
{
var node = new ElementNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name,
};
if (!string.IsNullOrEmpty(oldNode.BaseIdentifier))
{
connections.Add(new ConnectionData(oldNode.BaseIdentifier, oldNode.Identifier));
}
foreach (var item in oldNode.Properties)
{
node.ChildItems.Add(new PropertiesChildItem()
{
Identifier = item.Identifier,
Node = node,
Name = item.Name,
RelatedType = item.RelatedType
});
}
foreach (var item in oldNode.Collections)
{
node.ChildItems.Add(new CollectionsChildItem()
{
Identifier = item.Identifier,
Name = item.Name,
Node = node,
RelatedType = item.RelatedType
});
}
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<ViewData>())
{
var node = new ViewNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
// TODO CONVERT INHERITANCE
// Connect the scene property
foreach (var sceneProperty in oldNode.SceneProperties)
{
connections.Add(new ConnectionData(sceneProperty.Identifier, node.ScenePropertiesInputSlot.Identifier));
}
// TODO CONVERT BINDINGS
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<ViewComponentData>())
{
var node = new ViewComponentNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
// TODO CONVERT INHERITANCE
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<EnumData>())
{
var node = new EnumNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
foreach (var item in oldNode.EnumItems)
{
node.ChildItems.Add(new EnumChildItem()
{
Identifier = item.Identifier,
Node = node,
Name = item.Name
});
}
converted.Add(oldNode, node);
//Debug.Log(string.Format("Converted {0}", oldNode.Name));
}
foreach (var oldNode in oldGraph.NodeItems.OfType<StateMachineNodeData>())
{
var node = new StateMachineNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
if (oldNode.StartState != null)
{
connections.Add(new ConnectionData(node.StartStateOutputSlot.Identifier, oldNode.StartState.Identifier));
}
foreach (var transition in oldNode.Transitions)
{
node.ChildItems.Add(new TransitionsChildItem()
{
Name = transition.Name,
Identifier = transition.Identifier,
Node = node,
});
connections.Add(new ConnectionData(transition.PropertyIdentifier, transition.Identifier));
//connections.Add();
}
connections.Add(new ConnectionData(oldNode.StatePropertyIdentifier, oldNode.Identifier));
converted.Add(oldNode, node);
}
foreach (var oldNode in oldGraph.NodeItems.OfType<StateMachineStateData>())
{
var node = new StateNode()
{
Identifier = oldNode.Identifier,
Name = oldNode.Name
};
foreach (var transition in oldNode.Transitions)
{
node.ChildItems.Add(new StateTransitionsReference()
{
Name = transition.Name,
Identifier = transition.Identifier,
Node = node,
});
connections.Add(new ConnectionData(transition.Identifier, transition.TransitionToIdentifier));
}
converted.Add(oldNode, node);
}
// Grab all the connections
ConvertSubsystems(converted, connections);
ConvertSceneManagers(converted, connections);
ConvertElements(converted, connections);
ConvertStateMachines(converted, connections);
ConvertViews(converted, connections);
foreach (var item in converted.Values)
{
graphData.AddNode(item);
}
foreach (var item in connections)
{
if (item == null) continue;
if (item.OutputIdentifier == item.InputIdentifier)
{
continue;
}
graphData.AddConnection(item.OutputIdentifier, item.InputIdentifier);
Debug.Log(string.Format("Added connection {0} - {1}", item.OutputIdentifier, item.InputIdentifier));
}
// Reconstruct the filters
var oldElementGraph = oldGraph as IGraphData;
if (oldElementGraph != null)
{
foreach (var node in converted.Keys)
{
var newNOde = converted[node];
if (oldGraph.PositionData.HasPosition(oldGraph.RootFilter, node))
{
graph.SetItemLocation(newNOde, oldGraph.GetItemLocation(node));
}
}
foreach (var item in oldElementGraph.PositionData.Positions)
{
graph.PositionData.Positions.Add(item.Key, item.Value);
}
}
AssetDatabase.CreateAsset(graph, AssetDatabase.GetAssetPath(Selection.activeObject).Replace(".asset", "-new.asset"));
AssetDatabase.SaveAssets();
}
/// <summary>
/// Override this method for the enum node.
/// </summary>
/// <remarks>
/// This method is intended to be called from method overrides in subclasses.
/// This method also supports unit-testing scenarios and is not intended to be called from user code.
/// Call the Validate method to validate a <see cref="FilterQueryOption"/> instance.
/// </remarks>
/// <param name="enumNode"></param>
/// <param name="settings"></param>
public virtual void ValidateEnumNode(EnumNode enumNode, ODataValidationSettings settings)
{
if (enumNode == null)
{
throw Error.ArgumentNull("enumNode");
}
if (settings == null)
{
throw Error.ArgumentNull("settings");
}
// no default validation logic here
}
public static void Initialize(bool doNotLockFile, bool getDebugInfo){
if (SystemTypes.Initialized){
SystemTypes.Clear();
CoreSystemTypes.Initialize(doNotLockFile, getDebugInfo);
#if ExtendedRuntime
ExtendedRuntimeTypes.Initialize(doNotLockFile, getDebugInfo);
#endif
}else if (!CoreSystemTypes.Initialized){
CoreSystemTypes.Initialize(doNotLockFile, getDebugInfo);
#if ExtendedRuntime
ExtendedRuntimeTypes.Clear();
ExtendedRuntimeTypes.Initialize(doNotLockFile, getDebugInfo);
#endif
}
if (TargetPlatform.TargetVersion == null){
TargetPlatform.TargetVersion = SystemAssembly.Version;
if (TargetPlatform.TargetVersion == null)
TargetPlatform.TargetVersion = typeof(object).Module.Assembly.GetName().Version;
}
//TODO: throw an exception when the result is null
#if ExtendedRuntime
#if !NoData && !ROTOR
SystemDataAssembly = SystemTypes.GetSystemDataAssembly(doNotLockFile, getDebugInfo);
#endif
#if !NoXml && !NoRuntimeXml
SystemXmlAssembly = SystemTypes.GetSystemXmlAssembly(doNotLockFile, getDebugInfo);
#endif
#endif
AttributeUsageAttribute = (Class)GetTypeNodeFor("System", "AttributeUsageAttribute", ElementType.Class);
ConditionalAttribute = (Class)GetTypeNodeFor("System.Diagnostics", "ConditionalAttribute", ElementType.Class);
DefaultMemberAttribute = (Class)GetTypeNodeFor("System.Reflection", "DefaultMemberAttribute", ElementType.Class);
InternalsVisibleToAttribute = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "InternalsVisibleToAttribute", ElementType.Class);
ObsoleteAttribute = (Class)GetTypeNodeFor("System", "ObsoleteAttribute", ElementType.Class);
GenericICollection = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "ICollection", 1, ElementType.Class);
GenericIEnumerable = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IEnumerable", 1, ElementType.Class);
GenericIList = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IList", 1, ElementType.Class);
ICloneable = (Interface)GetTypeNodeFor("System", "ICloneable", ElementType.Class);
ICollection = (Interface)GetTypeNodeFor("System.Collections", "ICollection", ElementType.Class);
IEnumerable = (Interface)GetTypeNodeFor("System.Collections", "IEnumerable", ElementType.Class);
IList = (Interface)GetTypeNodeFor("System.Collections", "IList", ElementType.Class);
#if !MinimalReader
AllowPartiallyTrustedCallersAttribute = (Class)GetTypeNodeFor("System.Security", "AllowPartiallyTrustedCallersAttribute", ElementType.Class);
AssemblyCompanyAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyCompanyAttribute", ElementType.Class);
AssemblyConfigurationAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyConfigurationAttribute", ElementType.Class);
AssemblyCopyrightAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyCopyrightAttribute", ElementType.Class);
AssemblyCultureAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyCultureAttribute", ElementType.Class);
AssemblyDelaySignAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyDelaySignAttribute", ElementType.Class);
AssemblyDescriptionAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyDescriptionAttribute", ElementType.Class);
AssemblyFileVersionAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyFileVersionAttribute", ElementType.Class);
AssemblyFlagsAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyFlagsAttribute", ElementType.Class);
AssemblyInformationalVersionAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyInformationalVersionAttribute", ElementType.Class);
AssemblyKeyFileAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyKeyFileAttribute", ElementType.Class);
AssemblyKeyNameAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyKeyNameAttribute", ElementType.Class);
AssemblyProductAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyProductAttribute", ElementType.Class);
AssemblyTitleAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyTitleAttribute", ElementType.Class);
AssemblyTrademarkAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyTrademarkAttribute", ElementType.Class);
AssemblyVersionAttribute = (Class)GetTypeNodeFor("System.Reflection", "AssemblyVersionAttribute", ElementType.Class);
ClassInterfaceAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ClassInterfaceAttribute", ElementType.Class);
CLSCompliantAttribute = (Class)GetTypeNodeFor("System", "CLSCompliantAttribute", ElementType.Class);
ComImportAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ComImportAttribute", ElementType.Class);
ComRegisterFunctionAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ComRegisterFunctionAttribute", ElementType.Class);
ComSourceInterfacesAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ComSourceInterfacesAttribute", ElementType.Class);
ComUnregisterFunctionAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ComUnregisterFunctionAttribute", ElementType.Class);
ComVisibleAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ComVisibleAttribute", ElementType.Class);
DebuggableAttribute = (Class)GetTypeNodeFor("System.Diagnostics", "DebuggableAttribute", ElementType.Class);
DebuggerHiddenAttribute = (Class)GetTypeNodeFor("System.Diagnostics", "DebuggerHiddenAttribute", ElementType.Class);
DebuggerStepThroughAttribute = (Class)GetTypeNodeFor("System.Diagnostics", "DebuggerStepThroughAttribute", ElementType.Class);
DebuggingModes = DebuggableAttribute == null ? null : DebuggableAttribute.GetNestedType(Identifier.For("DebuggingModes")) as EnumNode;
DllImportAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "DllImportAttribute", ElementType.Class);
FieldOffsetAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "FieldOffsetAttribute", ElementType.Class);
FlagsAttribute = (Class)GetTypeNodeFor("System", "FlagsAttribute", ElementType.Class);
Guid = (Struct)GetTypeNodeFor("System", "Guid", ElementType.ValueType);
GuidAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "GuidAttribute", ElementType.Class);
ImportedFromTypeLibAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "ImportedFromTypeLibAttribute", ElementType.Class);
InAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "InAttribute", ElementType.Class);
IndexerNameAttribute = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "IndexerNameAttribute", ElementType.Class);
InterfaceTypeAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "InterfaceTypeAttribute", ElementType.Class);
MethodImplAttribute = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "MethodImplAttribute", ElementType.Class);
NonSerializedAttribute = (Class)GetTypeNodeFor("System", "NonSerializedAttribute", ElementType.Class);
OptionalAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "OptionalAttribute", ElementType.Class);
OutAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "OutAttribute", ElementType.Class);
ParamArrayAttribute = (Class)GetTypeNodeFor("System", "ParamArrayAttribute", ElementType.Class);
RuntimeCompatibilityAttribute = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "RuntimeCompatibilityAttribute", ElementType.Class);
SatelliteContractVersionAttribute = (Class)GetTypeNodeFor("System.Resources", "SatelliteContractVersionAttribute", ElementType.Class);
SerializableAttribute = (Class)GetTypeNodeFor("System", "SerializableAttribute", ElementType.Class);
SecurityAttribute = (Class)GetTypeNodeFor("System.Security.Permissions", "SecurityAttribute", ElementType.Class);
SecurityCriticalAttribute = (Class)GetTypeNodeFor("System.Security", "SecurityCriticalAttribute", ElementType.Class);
SecurityTransparentAttribute = (Class)GetTypeNodeFor("System.Security", "SecurityTransparentAttribute", ElementType.Class);
SecurityTreatAsSafeAttribute = (Class)GetTypeNodeFor("System.Security", "SecurityTreatAsSafeAttribute", ElementType.Class);
STAThreadAttribute = (Class)GetTypeNodeFor("System", "STAThreadAttribute", ElementType.Class);
StructLayoutAttribute = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "StructLayoutAttribute", ElementType.Class);
SuppressMessageAttribute = (Class)GetTypeNodeFor("System.Diagnostics.CodeAnalysis", "SuppressMessageAttribute", ElementType.Class);
SuppressUnmanagedCodeSecurityAttribute = (Class)GetTypeNodeFor("System.Security", "SuppressUnmanagedCodeSecurityAttribute", ElementType.Class);
SecurityAction = GetTypeNodeFor("System.Security.Permissions", "SecurityAction", ElementType.ValueType) as EnumNode;
DBNull = (Class)GetTypeNodeFor("System", "DBNull", ElementType.Class);
DateTime = (Struct)GetTypeNodeFor("System", "DateTime", ElementType.ValueType);
TimeSpan = (Struct)GetTypeNodeFor("System", "TimeSpan", ElementType.ValueType);
Activator = (Class)GetTypeNodeFor("System", "Activator", ElementType.Class);
AppDomain = (Class)GetTypeNodeFor("System", "AppDomain", ElementType.Class);
ApplicationException = (Class)GetTypeNodeFor("System", "ApplicationException", ElementType.Class);
ArgumentException = (Class)GetTypeNodeFor("System", "ArgumentException", ElementType.Class);
ArgumentNullException = (Class)GetTypeNodeFor("System", "ArgumentNullException", ElementType.Class);
ArgumentOutOfRangeException = (Class)GetTypeNodeFor("System", "ArgumentOutOfRangeException", ElementType.Class);
ArrayList = (Class)GetTypeNodeFor("System.Collections", "ArrayList", ElementType.Class);
AsyncCallback = (DelegateNode)GetTypeNodeFor("System", "AsyncCallback", ElementType.Class);
Assembly = (Class)GetTypeNodeFor("System.Reflection", "Assembly", ElementType.Class);
CodeAccessPermission = (Class)GetTypeNodeFor("System.Security", "CodeAccessPermission", ElementType.Class);
CollectionBase = (Class)GetTypeNodeFor("System.Collections", "CollectionBase", ElementType.Class);
CultureInfo = (Class)GetTypeNodeFor("System.Globalization", "CultureInfo", ElementType.Class);
DictionaryBase = (Class)GetTypeNodeFor("System.Collections", "DictionaryBase", ElementType.Class);
DictionaryEntry = (Struct)GetTypeNodeFor("System.Collections", "DictionaryEntry", ElementType.ValueType);
DuplicateWaitObjectException = (Class)GetTypeNodeFor("System", "DuplicateWaitObjectException", ElementType.Class);
Environment = (Class)GetTypeNodeFor("System", "Environment", ElementType.Class);
EventArgs = (Class)GetTypeNodeFor("System", "EventArgs", ElementType.Class);
ExecutionEngineException = (Class)GetTypeNodeFor("System", "ExecutionEngineException", ElementType.Class);
GenericArraySegment = (Struct)GetGenericRuntimeTypeNodeFor("System", "ArraySegment", 1, ElementType.ValueType);
GenericDictionary = (Class)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "Dictionary", 2, ElementType.Class);
GenericIComparable = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IComparable", 1, ElementType.Class);
GenericIComparer = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IComparer", 1, ElementType.Class);
GenericIDictionary = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IDictionary", 2, ElementType.Class);
GenericIEnumerator = (Interface)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "IEnumerator", 1, ElementType.Class);
GenericKeyValuePair = (Struct)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "KeyValuePair", 2, ElementType.ValueType);
GenericList = (Class)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "List", 1, ElementType.Class);
GenericNullable = (Struct)GetGenericRuntimeTypeNodeFor("System", "Nullable", 1, ElementType.ValueType);
GenericQueue = (Class)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "Queue", 1, ElementType.Class);
GenericSortedDictionary = (Class)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "SortedDictionary", 2, ElementType.Class);
GenericStack = (Class)GetGenericRuntimeTypeNodeFor("System.Collections.Generic", "Stack", 1, ElementType.Class);
GC = (Class)GetTypeNodeFor("System", "GC", ElementType.Class);
__HandleProtector = (Class)GetTypeNodeFor("System.Threading", "__HandleProtector", ElementType.Class);
HandleRef = (Struct)GetTypeNodeFor("System.Runtime.InteropServices", "HandleRef", ElementType.ValueType);
Hashtable = (Class)GetTypeNodeFor("System.Collections", "Hashtable", ElementType.Class);
IASyncResult = (Interface)GetTypeNodeFor("System", "IAsyncResult", ElementType.Class);
IComparable = (Interface)GetTypeNodeFor("System", "IComparable", ElementType.Class);
IComparer = (Interface)GetTypeNodeFor("System.Collections", "IComparer", ElementType.Class);
IDictionary = (Interface)GetTypeNodeFor("System.Collections", "IDictionary", ElementType.Class);
IDisposable = (Interface)GetTypeNodeFor("System", "IDisposable", ElementType.Class);
IEnumerator = (Interface)GetTypeNodeFor("System.Collections", "IEnumerator", ElementType.Class);
IFormatProvider = (Interface)GetTypeNodeFor("System", "IFormatProvider", ElementType.Class);
IHashCodeProvider = (Interface)GetTypeNodeFor("System.Collections", "IHashCodeProvider", ElementType.Class);
IMembershipCondition = (Interface)GetTypeNodeFor("System.Security.Policy", "IMembershipCondition", ElementType.Class);
IndexOutOfRangeException = (Class)GetTypeNodeFor("System", "IndexOutOfRangeException", ElementType.Class);
InvalidCastException = (Class)GetTypeNodeFor("System", "InvalidCastException", ElementType.Class);
InvalidOperationException = (Class)GetTypeNodeFor("System", "InvalidOperationException", ElementType.Class);
IPermission = (Interface)GetTypeNodeFor("System.Security", "IPermission", ElementType.Class);
ISerializable = (Interface)GetTypeNodeFor("System.Runtime.Serialization", "ISerializable", ElementType.Class);
IStackWalk = (Interface)GetTypeNodeFor("System.Security", "IStackWalk", ElementType.Class);
Marshal = (Class)GetTypeNodeFor("System.Runtime.InteropServices", "Marshal", ElementType.Class);
MarshalByRefObject = (Class)GetTypeNodeFor("System", "MarshalByRefObject", ElementType.Class);
MemberInfo = (Class)GetTypeNodeFor("System.Reflection", "MemberInfo", ElementType.Class);
Monitor = (Class)GetTypeNodeFor("System.Threading", "Monitor", ElementType.Class);
NativeOverlapped = (Struct)GetTypeNodeFor("System.Threading", "NativeOverlapped", ElementType.ValueType);
NotSupportedException = (Class)GetTypeNodeFor("System", "NotSupportedException", ElementType.Class);
NullReferenceException = (Class)GetTypeNodeFor("System", "NullReferenceException", ElementType.Class);
OutOfMemoryException = (Class)GetTypeNodeFor("System", "OutOfMemoryException", ElementType.Class);
ParameterInfo = (Class)GetTypeNodeFor("System.Reflection", "ParameterInfo", ElementType.Class);
Queue = (Class)GetTypeNodeFor("System.Collections", "Queue", ElementType.Class);
ReadOnlyCollectionBase = (Class)GetTypeNodeFor("System.Collections", "ReadOnlyCollectionBase", ElementType.Class);
ResourceManager = (Class)GetTypeNodeFor("System.Resources", "ResourceManager", ElementType.Class);
ResourceSet = (Class)GetTypeNodeFor("System.Resources", "ResourceSet", ElementType.Class);
SerializationInfo = (Class)GetTypeNodeFor("System.Runtime.Serialization", "SerializationInfo", ElementType.Class);
Stack = (Class)GetTypeNodeFor("System.Collections", "Stack", ElementType.Class);
StackOverflowException = (Class)GetTypeNodeFor("System", "StackOverflowException", ElementType.Class);
Stream = (Class)GetTypeNodeFor("System.IO", "Stream", ElementType.Class);
StreamingContext = (Struct)GetTypeNodeFor("System.Runtime.Serialization", "StreamingContext", ElementType.ValueType);
StringBuilder = (Class)GetTypeNodeFor("System.Text", "StringBuilder", ElementType.Class);
StringComparer = (Class)GetTypeNodeFor("System", "StringComparer", ElementType.Class);
StringComparison = GetTypeNodeFor("System", "StringComparison", ElementType.ValueType) as EnumNode;
SystemException = (Class)GetTypeNodeFor("System", "SystemException", ElementType.Class);
Thread = (Class)GetTypeNodeFor("System.Threading", "Thread", ElementType.Class);
WindowsImpersonationContext = (Class)GetTypeNodeFor("System.Security.Principal", "WindowsImpersonationContext", ElementType.Class);
#endif
#if ExtendedRuntime
#if !NoXml && !NoRuntimeXml
XmlAttributeAttributeClass = (Class)GetXmlTypeNodeFor("System.Xml.Serialization", "XmlAttributeAttribute", ElementType.Class);
XmlChoiceIdentifierAttributeClass = (Class)GetXmlTypeNodeFor("System.Xml.Serialization", "XmlChoiceIdentifierAttribute", ElementType.Class);
XmlElementAttributeClass = (Class)GetXmlTypeNodeFor("System.Xml.Serialization", "XmlElementAttribute", ElementType.Class);
XmlIgnoreAttributeClass = (Class)GetXmlTypeNodeFor("System.Xml.Serialization", "XmlIgnoreAttribute", ElementType.Class);
XmlTypeAttributeClass = (Class)GetXmlTypeNodeFor("System.Xml.Serialization", "XmlTypeAttribute", ElementType.Class);
#endif
#if !NoData
INullable = (Interface) GetDataTypeNodeFor("System.Data.SqlTypes", "INullable", ElementType.Class);
SqlBinary = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlBinary", ElementType.ValueType);
SqlBoolean = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlBoolean", ElementType.ValueType);
SqlByte = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlByte", ElementType.ValueType);
SqlDateTime = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlDateTime", ElementType.ValueType);
SqlDecimal = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlDecimal", ElementType.ValueType);
SqlDouble = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlDouble", ElementType.ValueType);
SqlGuid = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlGuid", ElementType.ValueType);
SqlInt16 = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlInt16", ElementType.ValueType);
SqlInt32 = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlInt32", ElementType.ValueType);
SqlInt64 = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlInt64", ElementType.ValueType);
SqlMoney = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlMoney", ElementType.ValueType);
SqlSingle = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlSingle", ElementType.ValueType);
SqlString = (Struct)GetDataTypeNodeFor("System.Data.SqlTypes", "SqlString", ElementType.ValueType);
IDbConnection = (Interface)GetDataTypeNodeFor("System.Data", "IDbConnection", ElementType.Class);
IDbTransaction = (Interface)GetDataTypeNodeFor("System.Data", "IDbTransaction", ElementType.Class);
IsolationLevel = GetDataTypeNodeFor("System.Data", "IsolationLevel", ElementType.ValueType) as EnumNode;
#endif
#if CCINamespace
const string CciNs = "Microsoft.Cci";
const string ContractsNs = "Microsoft.Contracts";
const string CompilerGuardsNs = "Microsoft.Contracts";
#else
const string CciNs = "System.Compiler";
const string ContractsNs = "Microsoft.Contracts";
const string CompilerGuardsNs = "Microsoft.Contracts";
#endif
const string GuardsNs = "Microsoft.Contracts";
AnonymousAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "AnonymousAttribute", ElementType.Class);
AnonymityEnum = GetCompilerRuntimeTypeNodeFor(CciNs, "Anonymity", ElementType.ValueType);
ComposerAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "ComposerAttribute", ElementType.Class);
CustomVisitorAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "CustomVisitorAttribute", ElementType.Class);
TemplateAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "TemplateAttribute", ElementType.Class);
TemplateInstanceAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "TemplateInstanceAttribute", ElementType.Class);
UnmanagedStructTemplateParameterAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "UnmanagedStructTemplateParameterAttribute", ElementType.Class);
TemplateParameterFlagsAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "TemplateParameterFlagsAttribute", ElementType.Class);
#if !WHIDBEYwithGenerics
GenericArrayToIEnumerableAdapter = (Class)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "ArrayToIEnumerableAdapter", 1, ElementType.Class);
#endif
GenericBoxed = (Struct)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "Boxed", 1, ElementType.ValueType);
GenericIEnumerableToGenericIListAdapter = (Class)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "GenericIEnumerableToGenericIListAdapter", 1, ElementType.Class);
GenericInvariant = (Struct)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "Invariant", 1, ElementType.ValueType);
GenericNonEmptyIEnumerable = (Struct)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "NonEmptyIEnumerable", 1, ElementType.ValueType);
GenericNonNull = (Struct)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "NonNull", 1, ElementType.ValueType);
GenericStreamUtility = (Class)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "StreamUtility", 1, ElementType.Class);
GenericUnboxer = (Class)GetCompilerRuntimeTypeNodeFor("StructuralTypes", "Unboxer", 1, ElementType.Class);
ElementTypeAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "ElementTypeAttribute", ElementType.Class);
IDbTransactable = (Interface)GetCompilerRuntimeTypeNodeFor("System.Data", "IDbTransactable", ElementType.Class);
IAggregate = (Interface)GetCompilerRuntimeTypeNodeFor("System.Query", "IAggregate", ElementType.Class);
IAggregateGroup = (Interface)GetCompilerRuntimeTypeNodeFor("System.Query", "IAggregateGroup", ElementType.Class);
StreamNotSingletonException = (Class)GetCompilerRuntimeTypeNodeFor("System.Query", "StreamNotSingletonException", ElementType.Class);
SqlHint = GetCompilerRuntimeTypeNodeFor("System.Query", "SqlHint", ElementType.ValueType) as EnumNode;
SqlFunctions = (Class)GetCompilerRuntimeTypeNodeFor("System.Query", "SqlFunctions", ElementType.Class);
#region Contracts
Range = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "Range", ElementType.Class);
//Ordinary Exceptions
NoChoiceException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "NoChoiceException", ElementType.Class);
IllegalUpcastException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "IllegalUpcastException", ElementType.Class);
CciMemberKind = (EnumNode)GetCompilerRuntimeTypeNodeFor(CciNs, "CciMemberKind", ElementType.ValueType);
CciMemberKindAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CciNs, "CciMemberKindAttribute", ElementType.Class);
//Checked Exceptions
ICheckedException = (Interface)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ICheckedException", ElementType.Class);
CheckedException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "CheckedException", ElementType.Class);
ContractMarkers = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ContractMarkers", ElementType.Class);
//Invariant
InitGuardSetsDelegate = (DelegateNode) GetCompilerRuntimeTypeNodeFor(GuardsNs, "InitGuardSetsDelegate", ElementType.Class);
CheckInvariantDelegate = (DelegateNode) GetCompilerRuntimeTypeNodeFor(GuardsNs, "CheckInvariantDelegate", ElementType.Class);
FrameGuardGetter = (DelegateNode) GetCompilerRuntimeTypeNodeFor(GuardsNs, "FrameGuardGetter", ElementType.Class);
ObjectInvariantException = (Class)GetCompilerRuntimeTypeNodeFor("Microsoft.Contracts", "ObjectInvariantException", ElementType.Class);
ThreadConditionDelegate = (DelegateNode) GetCompilerRuntimeTypeNodeFor(GuardsNs, "ThreadConditionDelegate", ElementType.Class);
GuardThreadStart = (DelegateNode) GetCompilerRuntimeTypeNodeFor(GuardsNs, "GuardThreadStart", ElementType.Class);
Guard = (Class) GetCompilerRuntimeTypeNodeFor(GuardsNs, "Guard", ElementType.Class);
ThreadStart = (DelegateNode) GetTypeNodeFor("System.Threading", "ThreadStart", ElementType.Class);
AssertHelpers = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "AssertHelpers", ElementType.Class);
#region Exceptions
UnreachableException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "UnreachableException", ElementType.Class);
ContractException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ContractException", ElementType.Class);
NullTypeException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "NullTypeException", ElementType.Class);
AssertException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "AssertException", ElementType.Class);
AssumeException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "AssumeException", ElementType.Class);
InvalidContractException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "InvalidContractException", ElementType.Class);
RequiresException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "RequiresException", ElementType.Class);
EnsuresException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "EnsuresException", ElementType.Class);
ModifiesException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ModifiesException", ElementType.Class);
ThrowsException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ThrowsException", ElementType.Class);
DoesException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "DoesException", ElementType.Class);
InvariantException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "InvariantException", ElementType.Class);
ContractMarkerException = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ContractMarkerException", ElementType.Class);
PreAllocatedExceptions = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "PreAllocatedExceptions", ElementType.Class);
#endregion
#region Attributes
AdditiveAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "AdditiveAttribute", ElementType.Class);
InsideAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "InsideAttribute", ElementType.Class);
PureAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "PureAttribute", ElementType.Class);
ConfinedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "ConfinedAttribute", ElementType.Class);
#region modelfield attributes and exceptions
ModelfieldContractAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ModelfieldContractAttribute", ElementType.Class);
ModelfieldAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ModelfieldAttribute", ElementType.Class);
SatisfiesAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "SatisfiesAttribute", ElementType.Class);
ModelfieldException = (Class)GetCompilerRuntimeTypeNodeFor("Microsoft.Contracts", "ModelfieldException", ElementType.Class);
#endregion
/* Diego's Attributes for Purity and WriteEffects */
OnceAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "OnceAttribute", ElementType.Class);
WriteConfinedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "WriteConfinedAttribute", ElementType.Class);
WriteAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "WriteAttribute", ElementType.Class);
ReadAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "ReadAttribute", ElementType.Class);
GlobalReadAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "GlobalReadAttribute", ElementType.Class);
GlobalWriteAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "GlobalWriteAttribute", ElementType.Class);
GlobalAccessAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "GlobalAccessAttribute", ElementType.Class);
FreshAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "FreshAttribute", ElementType.Class);
EscapesAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "EscapesAttribute", ElementType.Class);
/* */
StateIndependentAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "StateIndependentAttribute", ElementType.Class);
SpecPublicAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "SpecPublicAttribute", ElementType.Class);
SpecProtectedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "SpecProtectedAttribute", ElementType.Class);
SpecInternalAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "SpecInternalAttribute", ElementType.Class);
OwnedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "OwnedAttribute", ElementType.Class);
RepAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "RepAttribute", ElementType.Class);
PeerAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "PeerAttribute", ElementType.Class);
CapturedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "CapturedAttribute", ElementType.Class);
LockProtectedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "LockProtectedAttribute", ElementType.Class);
RequiresLockProtectedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "RequiresLockProtectedAttribute", ElementType.Class);
ImmutableAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "ImmutableAttribute", ElementType.Class);
RequiresImmutableAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "RequiresImmutableAttribute", ElementType.Class);
RequiresCanWriteAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "RequiresCanWriteAttribute", ElementType.Class);
ModelAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ModelAttribute", ElementType.Class);
RequiresAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "RequiresAttribute", ElementType.Class);
EnsuresAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "EnsuresAttribute", ElementType.Class);
ModifiesAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ModifiesAttribute", ElementType.Class);
HasWitnessAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "HasWitnessAttribute", ElementType.Class);
WitnessAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "WitnessAttribute", ElementType.Class);
InferredReturnValueAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "InferredReturnValueAttribute", ElementType.Class);
ThrowsAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ThrowsAttribute", ElementType.Class);
DoesAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "DoesAttribute", ElementType.Class);
InvariantAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "InvariantAttribute", ElementType.Class);
NoDefaultActivityAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "NoDefaultActivityAttribute", ElementType.Class);
NoDefaultContractAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "NoDefaultContractAttribute", ElementType.Class);
ReaderAttribute = (Class)GetCompilerRuntimeTypeNodeFor(CompilerGuardsNs, "ReaderAttribute", ElementType.Class);
ShadowsAssemblyAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ShadowsAssemblyAttribute", ElementType.Class);
VerifyAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "VerifyAttribute", ElementType.Class);
DependentAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "DependentAttribute", ElementType.Class);
ElementsRepAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ElementsRepAttribute", ElementType.Class);
ElementsPeerAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ElementsPeerAttribute", ElementType.Class);
ElementAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ElementAttribute", ElementType.Class);
ElementCollectionAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ElementCollectionAttribute", ElementType.Class);
RecursionTerminationAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "RecursionTerminationAttribute", ElementType.Class);
NoReferenceComparisonAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "NoReferenceComparisonAttribute", ElementType.Class);
ResultNotNewlyAllocatedAttribute = (Class)GetCompilerRuntimeTypeNodeFor(ContractsNs, "ResultNotNewlyAllocatedAttribute", ElementType.Class);
#endregion
#endregion
#endif
SystemTypes.Initialized = true;
object dummy = TargetPlatform.AssemblyReferenceFor; //Force selection of target platform
if (dummy == null) return;
}
public virtual EnumNode VisitEnumNode(EnumNode enumNode) {
return (EnumNode)this.VisitTypeNode(enumNode);
}
public override void ValidateEnumNode(EnumNode enumNode, ODataValidationSettings settings)
{
IncrementCount("ValidateEnumQueryNode");
base.ValidateEnumNode(enumNode, settings);
}
public virtual Differences VisitEnumNode(EnumNode enumNode1, EnumNode enumNode2){
Differences differences = this.GetMemberDifferences(enumNode1, enumNode2);
if (differences == null){Debug.Assert(false); differences = new Differences(enumNode1, enumNode2);}
if (differences.NumberOfDifferences > 0 || differences.NumberOfSimilarities > 0) return differences;
if (enumNode1 == null || enumNode2 == null){
if (enumNode1 != enumNode2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
Differences diff = this.VisitTypeNode(enumNode1, enumNode2);
if (diff == null){Debug.Assert(false); return differences;}
differences.NumberOfDifferences = diff.NumberOfDifferences;
differences.NumberOfSimilarities = diff.NumberOfSimilarities;
EnumNode changes = (EnumNode)diff.Changes;
EnumNode deletions = (EnumNode)diff.Deletions;
EnumNode insertions = (EnumNode)diff.Insertions;
diff = this.VisitTypeNode(enumNode1.UnderlyingType, enumNode2.UnderlyingType);
if (diff == null){Debug.Assert(false); return differences;}
if (changes != null) changes.UnderlyingType = diff.Changes as TypeNode;
if (deletions != null) deletions.UnderlyingType = diff.Deletions as TypeNode;
if (insertions != null) insertions.UnderlyingType = diff.Insertions as TypeNode;
//Debug.Assert(diff.Changes == changes.UnderlyingType && diff.Deletions == deletions.UnderlyingType && diff.Insertions == insertions.UnderlyingType);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
//────────────────────────────────────────
/// <summary>
///
/// </summary>
public Pen CreatePen(EnumNode enumNode)
{
Pen result;
switch(enumNode)
{
case EnumNode.Scene:
//シーン用ペン。
result = new Pen(Color.FromArgb(255, 192, 0, 0));
break;
case EnumNode.Actor:
//アクター用ペン。
result = new Pen(Color.FromArgb(255, 179, 183, 0));
break;
case EnumNode.Thread:
//スレッド用ペン。
result = new Pen(Color.FromArgb(255, 64, 0, 164));
break;
case EnumNode.Comment:
result = new Pen(Color.FromArgb(255, 192, 192, 192));
break;
case EnumNode.Error:
default:
result = new Pen(Color.FromArgb(255, 212, 0, 0));
break;
}
return result;
}
public static void InitializeSystemTypes()
{
// This must be done in the order: Object, ValueType, Char, String
// or else some of the generic type instantiations don't get filled
// in correctly. (String ends up implementing IEnumerable<string>
// instead of IEnumerable<char>.)
Object = (Class)GetTypeNodeFor("System", "Object", ElementType.Object);
ValueType = (Class)GetTypeNodeFor("System", "ValueType", ElementType.Class);
Char = (Struct)GetTypeNodeFor("System", "Char", ElementType.Char);
String = (Class)GetTypeNodeFor("System", "String", ElementType.String);
Enum = (Class)GetTypeNodeFor("System", "Enum", ElementType.Class);
MulticastDelegate = (Class)GetTypeNodeFor("System", "MulticastDelegate", ElementType.Class);
Array = (Class)GetTypeNodeFor("System", "Array", ElementType.Class);
Type = (Class)GetTypeNodeFor("System", "Type", ElementType.Class);
Boolean = (Struct)GetTypeNodeFor("System", "Boolean", ElementType.Boolean);
Int8 = (Struct)GetTypeNodeFor("System", "SByte", ElementType.Int8);
UInt8 = (Struct)GetTypeNodeFor("System", "Byte", ElementType.UInt8);
Int16 = (Struct)GetTypeNodeFor("System", "Int16", ElementType.Int16);
UInt16 = (Struct)GetTypeNodeFor("System", "UInt16", ElementType.UInt16);
Int32 = (Struct)GetTypeNodeFor("System", "Int32", ElementType.Int32);
UInt32 = (Struct)GetTypeNodeFor("System", "UInt32", ElementType.UInt32);
Int64 = (Struct)GetTypeNodeFor("System", "Int64", ElementType.Int64);
UInt64 = (Struct)GetTypeNodeFor("System", "UInt64", ElementType.UInt64);
Single = (Struct)GetTypeNodeFor("System", "Single", ElementType.Single);
Double = (Struct)GetTypeNodeFor("System", "Double", ElementType.Double);
IntPtr = (Struct)GetTypeNodeFor("System", "IntPtr", ElementType.IntPtr);
UIntPtr = (Struct)GetTypeNodeFor("System", "UIntPtr", ElementType.UIntPtr);
DynamicallyTypedReference = (Struct)GetTypeNodeFor("System", "TypedReference", ElementType.DynamicallyTypedReference);
#if !MinimalReader
Delegate = (Class)GetTypeNodeFor("System", "Delegate", ElementType.Class);
Exception = (Class)GetTypeNodeFor("System", "Exception", ElementType.Class);
Attribute = (Class)GetTypeNodeFor("System", "Attribute", ElementType.Class);
DBNull = (Class)GetTypeNodeFor("System", "DBNull", ElementType.Class);
DateTime = (Struct)GetTypeNodeFor("System", "DateTime", ElementType.ValueType);
Decimal = (Struct)GetTypeNodeFor("System", "Decimal", ElementType.ValueType);
#endif
ArgIterator = (Struct)GetTypeNodeFor("System", "ArgIterator", ElementType.ValueType);
IsVolatile = (Class)GetTypeNodeFor("System.Runtime.CompilerServices", "IsVolatile", ElementType.Class);
Void = (Struct)GetTypeNodeFor("System", "Void", ElementType.Void);
RuntimeFieldHandle = (Struct)GetTypeNodeFor("System", "RuntimeFieldHandle", ElementType.ValueType);
RuntimeMethodHandle = (Struct)GetTypeNodeFor("System", "RuntimeMethodHandle", ElementType.ValueType);
RuntimeTypeHandle = (Struct)GetTypeNodeFor("System", "RuntimeTypeHandle", ElementType.ValueType);
#if !MinimalReader
RuntimeArgumentHandle = (Struct)GetTypeNodeFor("System", "RuntimeArgumentHandle", ElementType.ValueType);
#endif
SecurityAction = GetTypeNodeFor("System.Security.Permissions", "SecurityAction", ElementType.ValueType) as EnumNode;
CoreSystemTypes.Initialized = true;
CoreSystemTypes.InstantiateGenericInterfaces();
#if !NoWriter
Literal.Initialize();
#endif
object dummy = TargetPlatform.AssemblyReferenceFor; //Force selection of target platform
if (dummy == null) return;
}
//────────────────────────────────────────
/// <summary>
///
/// </summary>
public Brush CreateBrush(EnumNode enumNode)
{
Brush result;
switch (enumNode)
{
case EnumNode.Scene:
//シーン用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 192, 0, 0));
break;
case EnumNode.Actor:
//アクター用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 179, 183, 0));
break;
case EnumNode.Thread:
//スレッド用ブラシ。
result = new SolidBrush(Color.FromArgb(255, 64, 0, 164));
break;
case EnumNode.Comment:
result = new SolidBrush(Color.FromArgb(255, 192, 192, 192));
break;
case EnumNode.Error:
default:
result = new SolidBrush(Color.FromArgb(255, 212, 0, 0));
break;
}
return result;
}
private EnumNode TranslateToEnum(CodeTypeDeclaration typeDec, Identifier nameSpace, TypeNode declaringType){
Debug.Assert(typeDec != null);
EnumNode e = new EnumNode();
e.Attributes = this.Translate(typeDec.CustomAttributes, null);
e.DeclaringModule = this.targetModule;
if (declaringType == null) this.targetModule.Types.Add(e);
e.DeclaringType = declaringType;
e.Name = Identifier.For(typeDec.Name);
e.Namespace = nameSpace;
TypeNode underlyingType = SystemTypes.Int32;
this.SetTypeFlags(e, typeDec.TypeAttributes);
if (typeDec.BaseTypes != null && typeDec.BaseTypes.Count > 0){
MemberBinding texpr = this.Translate(typeDec.BaseTypes[0]);
if (texpr != null && texpr.BoundMember is TypeNode)
underlyingType = (TypeNode)texpr.BoundMember;
}
e.Members = new MemberList();
e.UnderlyingType = underlyingType;
this.Translate(typeDec.Members, e);
if (declaringType != null) declaringType.Members.Add(e);
return e;
}
private void GetUnderlyingTypeOfEnumNode(EnumNode /*!*/enumNode, FieldRow[]/*!*/ fieldDefs, FieldPtrRow[]/*!*/ fieldPtrs, int start, int end)
{
TypeNode underlyingType = null;
for (int i = start; i < end; i++)
{
int ii = i;
if (fieldPtrs.Length > 0) ii = fieldPtrs[i - 1].Field;
FieldRow fld = fieldDefs[ii - 1];
if (fld.Field != null && !fld.Field.IsStatic)
{
underlyingType = fld.Field.Type;
break;
}
FieldFlags fieldFlags = (FieldFlags)fld.Flags;
if ((fieldFlags & FieldFlags.Static) == 0)
{
this.tables.GetSignatureLength(fld.Signature);
MemoryCursor sigReader = this.tables.GetNewCursor();
GetAndCheckSignatureToken(6, sigReader);
underlyingType = this.ParseTypeSignature(sigReader);
break;
}
}
enumNode.underlyingType = underlyingType;
}
public BaseNode AddEnum(string id, string name, string file)
{
EnumNode enumn = new EnumNode(id, name, file);
nodemap.Add(id, enumn);
return enumn;
}
internal static TypeNode/*!*/ GetDummyTypeNode(AssemblyNode declaringAssembly, string/*!*/ nspace, string/*!*/ name, ElementType typeCode) {
TypeNode result = null;
switch (typeCode) {
case ElementType.Object:
case ElementType.String:
case ElementType.Class:
if (name.Length > 1 && name[0] == 'I' && char.IsUpper(name[1]))
result = new Interface();
else if (name == "MulticastDelegate" || name == "Delegate")
result = new Class();
else if (name.EndsWith("Callback") || name.EndsWith("Delegate") || name == "ThreadStart" || name == "FrameGuardGetter" || name == "GuardThreadStart")
result = new DelegateNode();
else
result = new Class();
break;
default:
if (name == "CciMemberKind")
result = new EnumNode();
else
result = new Struct();
break;
}
result.Name = Identifier.For(name);
result.Namespace = Identifier.For(nspace);
result.DeclaringModule = declaringAssembly;
return result;
}
