public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			Push();
			object result = base.VisitConstructorDeclaration(constructorDeclaration, data);
			Pop();
			return result;
		}
		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			throw new global::System.NotImplementedException("ConstructorDeclaration");
		}
		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			Debug.Assert((constructorDeclaration != null));
			Debug.Assert((constructorDeclaration.Attributes != null));
			Debug.Assert((constructorDeclaration.Parameters != null));
			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
			Debug.Assert((constructorDeclaration.Body != null));
			foreach (AttributeSection o in constructorDeclaration.Attributes) {
				Debug.Assert(o != null);
				o.AcceptVisitor(this, data);
			}
			foreach (ParameterDeclarationExpression o in constructorDeclaration.Parameters) {
				Debug.Assert(o != null);
				o.AcceptVisitor(this, data);
			}
			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
			return constructorDeclaration.Body.AcceptVisitor(this, data);
		}
		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			Debug.Assert((constructorDeclaration != null));
			Debug.Assert((constructorDeclaration.Attributes != null));
			Debug.Assert((constructorDeclaration.Parameters != null));
			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
			Debug.Assert((constructorDeclaration.Body != null));
			for (int i = 0; i < constructorDeclaration.Attributes.Count; i++) {
				AttributeSection o = constructorDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					constructorDeclaration.Attributes.RemoveAt(i--);
				else
					constructorDeclaration.Attributes[i] = o;
			}
			for (int i = 0; i < constructorDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = constructorDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					constructorDeclaration.Parameters.RemoveAt(i--);
				else
					constructorDeclaration.Parameters[i] = o;
			}
			nodeStack.Push(constructorDeclaration.ConstructorInitializer);
			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
			constructorDeclaration.ConstructorInitializer = ((ConstructorInitializer)(nodeStack.Pop()));
			nodeStack.Push(constructorDeclaration.Body);
			constructorDeclaration.Body.AcceptVisitor(this, data);
			constructorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
			return null;
		}
Beispiel #5
0
	void StructureMemberDecl(ModifierList m, List<AttributeSection> attributes) {
		TypeReference type = null;
		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
		Statement stmt = null;
		List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>();
		List<TemplateDefinition> templates = new List<TemplateDefinition>();

		switch (la.kind) {
		case 84: case 103: case 115: case 142: case 155: case 209: {
			NonModuleDeclaration(m, attributes);
			break;
		}
		case 210: {
			Get();
			Location startPos = t.Location;

			if (StartOf(5)) {
				string name = String.Empty;
					MethodDeclaration methodDeclaration; List<string> handlesClause = null;
					List<InterfaceImplementation> implementsClause = null;

				Identifier();
				name = t.val;
					m.Check(Modifiers.VBMethods);

				TypeParameterList(templates);
				if (la.kind == 37) {
					Get();
					if (StartOf(7)) {
						FormalParameterList(p);
					}
					Expect(38);
				}
				if (la.kind == 134 || la.kind == 136) {
					if (la.kind == 136) {
						ImplementsClause(out implementsClause);
					} else {
						HandlesClause(out handlesClause);
					}
				}
				Location endLocation = t.EndLocation;
				if (IsMustOverride(m)) {
					EndOfStmt();
					methodDeclaration = new MethodDeclaration {
							Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
							StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
							TypeReference = new TypeReference("System.Void", true),
							Templates = templates,
							HandlesClause = handlesClause,
							InterfaceImplementations = implementsClause
						};
						AddChild(methodDeclaration);

				} else if (la.kind == 1) {
					Get();
					methodDeclaration = new MethodDeclaration {
							Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
							StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
							TypeReference = new TypeReference("System.Void", true),
							Templates = templates,
							HandlesClause = handlesClause,
							InterfaceImplementations = implementsClause
						};
						AddChild(methodDeclaration);

					if (ParseMethodBodies) {
					Block(out stmt);
					Expect(113);
					Expect(210);
					} else {
						// don't parse method body
						lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
					   }

					methodDeclaration.Body  = (BlockStatement)stmt;
					methodDeclaration.Body.EndLocation = t.EndLocation;
					EndOfStmt();
				} else SynErr(257);
			} else if (la.kind == 162) {
				Get();
				if (la.kind == 37) {
					Get();
					if (StartOf(7)) {
						FormalParameterList(p);
					}
					Expect(38);
				}
				m.Check(Modifiers.Constructors);
				Location constructorEndLocation = t.EndLocation;
				Expect(1);
				if (ParseMethodBodies) {
				Block(out stmt);
				Expect(113);
				Expect(210);
				} else {
					// don't parse method body
					lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
				   }

				Location endLocation = t.EndLocation;
				EndOfStmt();
				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
					cd.StartLocation = m.GetDeclarationLocation(startPos);
					cd.EndLocation   = constructorEndLocation;
					cd.Body = (BlockStatement)stmt;
					cd.Body.EndLocation   = endLocation;
					AddChild(cd);

			} else SynErr(258);
			break;
		}
		case 127: {
			Get();
			m.Check(Modifiers.VBMethods);
				string name = String.Empty;
				Location startPos = t.Location;
				MethodDeclaration methodDeclaration;List<string> handlesClause = null;
				List<InterfaceImplementation> implementsClause = null;
				AttributeSection returnTypeAttributeSection = null;

			Identifier();
			name = t.val;
			TypeParameterList(templates);
			if (la.kind == 37) {
				Get();
				if (StartOf(7)) {
					FormalParameterList(p);
				}
				Expect(38);
			}
			if (la.kind == 63) {
				Get();
				while (la.kind == 40) {
					AttributeSection(out returnTypeAttributeSection);
					if (returnTypeAttributeSection != null) {
							returnTypeAttributeSection.AttributeTarget = "return";
							attributes.Add(returnTypeAttributeSection);
						}

				}
				TypeName(out type);
			}
			if(type == null) {
					type = new TypeReference("System.Object", true);
				}

			if (la.kind == 134 || la.kind == 136) {
				if (la.kind == 136) {
					ImplementsClause(out implementsClause);
				} else {
					HandlesClause(out handlesClause);
				}
			}
			Location endLocation = t.EndLocation;
			if (IsMustOverride(m)) {
				EndOfStmt();
				methodDeclaration = new MethodDeclaration {
						Name = name, Modifier = m.Modifier, TypeReference = type,
						Parameters = p, Attributes = attributes,
						StartLocation = m.GetDeclarationLocation(startPos),
						EndLocation   = endLocation,
						HandlesClause = handlesClause,
						Templates     = templates,
						InterfaceImplementations = implementsClause
					};
					
					AddChild(methodDeclaration);

			} else if (la.kind == 1) {
				Get();
				methodDeclaration = new MethodDeclaration {
						Name = name, Modifier = m.Modifier, TypeReference = type,
						Parameters = p, Attributes = attributes,
						StartLocation = m.GetDeclarationLocation(startPos),
						EndLocation   = endLocation,
						Templates     = templates,
						HandlesClause = handlesClause,
						InterfaceImplementations = implementsClause
					};
					
					AddChild(methodDeclaration);

					if (ParseMethodBodies) {
				Block(out stmt);
				Expect(113);
				Expect(127);
				} else {
						// don't parse method body
						lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
					}
					methodDeclaration.Body = (BlockStatement)stmt;
					methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
					methodDeclaration.Body.EndLocation   = t.EndLocation;

				EndOfStmt();
			} else SynErr(259);
			break;
		}
		case 101: {
			Get();
			m.Check(Modifiers.VBExternalMethods);
				Location startPos = t.Location;
				CharsetModifier charsetModifer = CharsetModifier.None;
				string library = String.Empty;
				string alias = null;
				string name = String.Empty;

			if (StartOf(16)) {
				Charset(out charsetModifer);
			}
			if (la.kind == 210) {
				Get();
				Identifier();
				name = t.val;
				Expect(149);
				Expect(3);
				library = t.literalValue as string;
				if (la.kind == 59) {
					Get();
					Expect(3);
					alias = t.literalValue as string;
				}
				if (la.kind == 37) {
					Get();
					if (StartOf(7)) {
						FormalParameterList(p);
					}
					Expect(38);
				}
				EndOfStmt();
				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
					declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
					declareDeclaration.EndLocation   = t.EndLocation;
					AddChild(declareDeclaration);

			} else if (la.kind == 127) {
				Get();
				Identifier();
				name = t.val;
				Expect(149);
				Expect(3);
				library = t.literalValue as string;
				if (la.kind == 59) {
					Get();
					Expect(3);
					alias = t.literalValue as string;
				}
				if (la.kind == 37) {
					Get();
					if (StartOf(7)) {
						FormalParameterList(p);
					}
					Expect(38);
				}
				if (la.kind == 63) {
					Get();
					TypeName(out type);
				}
				EndOfStmt();
				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
					declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
					declareDeclaration.EndLocation   = t.EndLocation;
					AddChild(declareDeclaration);

			} else SynErr(260);
			break;
		}
		case 119: {
			Get();
			m.Check(Modifiers.VBEvents);
				Location startPos = t.Location;
				EventDeclaration eventDeclaration;
				string name = String.Empty;
				List<InterfaceImplementation> implementsClause = null;

			Identifier();
			name= t.val;
			if (la.kind == 63) {
				Get();
				TypeName(out type);
			} else if (StartOf(17)) {
				if (la.kind == 37) {
					Get();
					if (StartOf(7)) {
						FormalParameterList(p);
					}
					Expect(38);
				}
			} else SynErr(261);
			if (la.kind == 136) {
				ImplementsClause(out implementsClause);
			}
			eventDeclaration = new EventDeclaration {
					Name = name, TypeReference = type, Modifier = m.Modifier, 
					Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
					StartLocation = m.GetDeclarationLocation(startPos),
					EndLocation = t.EndLocation
				};
				AddChild(eventDeclaration);

			EndOfStmt();
			break;
		}
		case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
			m.Check(Modifiers.Fields);
				FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);

			IdentifierForFieldDeclaration();
			string name = t.val;
			fd.StartLocation = m.GetDeclarationLocation(t.Location);
			VariableDeclaratorPartAfterIdentifier(variableDeclarators, name);
			while (la.kind == 22) {
				Get();
				VariableDeclarator(variableDeclarators);
			}
			EndOfStmt();
			fd.EndLocation = t.EndLocation;
				fd.Fields = variableDeclarators;
				AddChild(fd);

			break;
		}
		case 88: {
			m.Check(Modifiers.Fields);
			Get();
			m.Add(Modifiers.Const, t.Location); 
			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
				fd.StartLocation = m.GetDeclarationLocation(t.Location);
				List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();

			ConstantDeclarator(constantDeclarators);
			while (la.kind == 22) {
				Get();
				ConstantDeclarator(constantDeclarators);
			}
			fd.Fields = constantDeclarators;
				fd.EndLocation = t.Location;

			EndOfStmt();
			fd.EndLocation = t.EndLocation;
				AddChild(fd);

			break;
		}
		case 186: {
			Get();
			m.Check(Modifiers.VBProperties);
				Location startPos = t.Location;
				List<InterfaceImplementation> implementsClause = null;
				AttributeSection returnTypeAttributeSection = null;
				Expression initializer = null;

			Identifier();
			string propertyName = t.val;
			if (la.kind == 37) {
				Get();
				if (StartOf(7)) {
					FormalParameterList(p);
				}
				Expect(38);
			}
			if (la.kind == 63) {
				Get();
				while (la.kind == 40) {
					AttributeSection(out returnTypeAttributeSection);
					if (returnTypeAttributeSection != null) {
							returnTypeAttributeSection.AttributeTarget = "return";
							attributes.Add(returnTypeAttributeSection);
						}

				}
				if (IsNewExpression()) {
					ObjectCreateExpression(out initializer);
					if (initializer is ObjectCreateExpression) {
							type = ((ObjectCreateExpression)initializer).CreateType.Clone();
						} else {
							type = ((ArrayCreateExpression)initializer).CreateType.Clone();
						}

				} else if (StartOf(9)) {
					TypeName(out type);
				} else SynErr(262);
			}
			if (la.kind == 20) {
				Get();
				Expr(out initializer);
			}
			if (la.kind == 136) {
				ImplementsClause(out implementsClause);
			}
			EndOfStmt();
			if (IsMustOverride(m) || IsAutomaticProperty()) {
				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
					pDecl.StartLocation = m.GetDeclarationLocation(startPos);
					pDecl.EndLocation   = t.Location;
					pDecl.TypeReference = type;
					pDecl.InterfaceImplementations = implementsClause;
					pDecl.Parameters = p;
					if (initializer != null)
						pDecl.Initializer = initializer;
					AddChild(pDecl);

			} else if (StartOf(18)) {
				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
					pDecl.StartLocation = m.GetDeclarationLocation(startPos);
					pDecl.EndLocation   = t.Location;
					pDecl.BodyStart   = t.Location;
					pDecl.TypeReference = type;
					pDecl.InterfaceImplementations = implementsClause;
					pDecl.Parameters = p;
					PropertyGetRegion getRegion;
					PropertySetRegion setRegion;

				AccessorDecls(out getRegion, out setRegion);
				Expect(113);
				Expect(186);
				EndOfStmt();
				pDecl.GetRegion = getRegion;
					pDecl.SetRegion = setRegion;
					pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
					AddChild(pDecl);

			} else SynErr(263);
			break;
		}
		case 98: {
			Get();
			Location startPos = t.Location;
			Expect(119);
			m.Check(Modifiers.VBCustomEvents);
				EventAddRemoveRegion eventAccessorDeclaration;
				EventAddRegion addHandlerAccessorDeclaration = null;
				EventRemoveRegion removeHandlerAccessorDeclaration = null;
				EventRaiseRegion raiseEventAccessorDeclaration = null;
				List<InterfaceImplementation> implementsClause = null;

			Identifier();
			string customEventName = t.val;
			Expect(63);
			TypeName(out type);
			if (la.kind == 136) {
				ImplementsClause(out implementsClause);
			}
			EndOfStmt();
			while (StartOf(19)) {
				EventAccessorDeclaration(out eventAccessorDeclaration);
				if(eventAccessorDeclaration is EventAddRegion)
					{
						addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
					}
					else if(eventAccessorDeclaration is EventRemoveRegion)
					{
						removeHandlerAccessorDeclaration = (EventRemoveRegion)eventAccessorDeclaration;
					}
					else if(eventAccessorDeclaration is EventRaiseRegion)
					{
						raiseEventAccessorDeclaration = (EventRaiseRegion)eventAccessorDeclaration;
					}

			}
			Expect(113);
			Expect(119);
			EndOfStmt();
			if(addHandlerAccessorDeclaration == null)
				{
					Error("Need to provide AddHandler accessor.");
				}
				
				if(removeHandlerAccessorDeclaration == null)
				{
					Error("Need to provide RemoveHandler accessor.");
				}
				
				if(raiseEventAccessorDeclaration == null)
				{
					Error("Need to provide RaiseEvent accessor.");
				}

				EventDeclaration decl = new EventDeclaration {
					TypeReference = type, Name = customEventName, Modifier = m.Modifier,
					Attributes = attributes,
					StartLocation = m.GetDeclarationLocation(startPos),
					EndLocation = t.EndLocation,
					AddRegion = addHandlerAccessorDeclaration,
					RemoveRegion = removeHandlerAccessorDeclaration,
					RaiseRegion = raiseEventAccessorDeclaration
				};
				AddChild(decl);

			break;
		}
		case 161: case 172: case 232: {
			ConversionType opConversionType = ConversionType.None;
			if (la.kind == 161 || la.kind == 232) {
				if (la.kind == 232) {
					Get();
					opConversionType = ConversionType.Implicit;
				} else {
					Get();
					opConversionType = ConversionType.Explicit;
				}
			}
			Expect(172);
			m.Check(Modifiers.VBOperators);
				Location startPos = t.Location;
				TypeReference returnType = NullTypeReference.Instance;
				TypeReference operandType = NullTypeReference.Instance;
				OverloadableOperatorType operatorType;
				AttributeSection section;
				ParameterDeclarationExpression param;
				List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();

			OverloadableOperator(out operatorType);
			Expect(37);
			FormalParameter(out param);
			if (param != null) parameters.Add(param);
			if (la.kind == 22) {
				Get();
				FormalParameter(out param);
				if (param != null) parameters.Add(param);
			}
			Expect(38);
			Location endPos = t.EndLocation;
			if (la.kind == 63) {
				Get();
				while (la.kind == 40) {
					AttributeSection(out section);
					if (section != null) {
						section.AttributeTarget = "return";
						attributes.Add(section);
					}
				}
				TypeName(out returnType);
				endPos = t.EndLocation;
			}
			Expect(1);
			Block(out stmt);
			Expect(113);
			Expect(172);
			EndOfStmt();
			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
					Modifier = m.Modifier,
					Attributes = attributes,
					Parameters = parameters,
					TypeReference = returnType,
					OverloadableOperator = operatorType,
					ConversionType = opConversionType,
					Body = (BlockStatement)stmt,
					StartLocation = m.GetDeclarationLocation(startPos),
					EndLocation = endPos
				};
				operatorDeclaration.Body.StartLocation = startPos;
				operatorDeclaration.Body.EndLocation = t.Location;
				AddChild(operatorDeclaration);

			break;
		}
		default: SynErr(264); break;
		}
	}
		public virtual object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			return base.VisitConstructorDeclaration(constructorDeclaration, data);
		}
		public sealed override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			this.BeginVisit(constructorDeclaration);
			object result = this.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
			this.EndVisit(constructorDeclaration);
			return result;
		}
		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
			InitMethodScope();

			CodeConstructor memberMethod = new CodeConstructor();
			memberMethod.Attributes = ConvMemberAttributes(constructorDeclaration.Modifier);

			typeDeclarations.Peek().Members.Add(memberMethod);

			codeStack.Push(NullStmtCollection);
			foreach (ParameterDeclarationExpression parameter in constructorDeclaration.Parameters)
			{
				memberMethod.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
			}
			
			if (constructorDeclaration.ConstructorInitializer != null)
			{
				if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base)
				{
					if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
					{
						memberMethod.BaseConstructorArgs.Add(new CodeSnippetExpression());
					}
					
					foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
					{
						memberMethod.BaseConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
					}
				}

				if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This)
				{
					if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
					{
						memberMethod.ChainedConstructorArgs.Add(new CodeSnippetExpression());
					}

					foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
					{
						memberMethod.ChainedConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
					}
				}
			}
			codeStack.Pop();

			codeStack.Push(memberMethod.Statements);
			constructorDeclaration.Body.AcceptChildren(this, data);
			codeStack.Pop();
			
			return null;
		}