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(); }
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; }