public override object Visit(MethodDeclaration methodDeclaration, object data)
 {
     CodeMemberMethod memberMethod = new CodeMemberMethod();
     memberMethod.Name = methodDeclaration.Name;
     currentMethod = memberMethod;
     ((CodeTypeDeclaration)typeDeclarations.Peek()).Members.Add(memberMethod);
     if (memberMethod.Name.ToUpper() == "INITIALIZECOMPONENT") {
         methodDeclaration.Body.AcceptChildren(this, data);
     }
     currentMethod = null;
     return null;
 }
	void InterfaceMemberDecl() {

#line  760 "VBNET.ATG" 
		TypeReference type =null;
		ArrayList p = null;
		AttributeSection section;
		Modifiers mod = new Modifiers(this);
		ArrayList attributes = new ArrayList();
		/*ArrayList parameters = new ArrayList();*/
		string name;
		
		if (StartOf(12)) {
			while (la.kind == 28) {
				AttributeSection(
#line  768 "VBNET.ATG" 
out section);

#line  768 "VBNET.ATG" 
				attributes.Add(section); 
			}
			while (StartOf(6)) {
				MemberModifier(
#line  772 "VBNET.ATG" 
mod);
			}
			if (la.kind == 94) {
				lexer.NextToken();

#line  775 "VBNET.ATG" 
				mod.Check(Modifier.InterfaceEvents); 
				Identifier();

#line  776 "VBNET.ATG" 
				name = t.val; 
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  777 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				if (la.kind == 49) {
					lexer.NextToken();
					TypeName(
#line  778 "VBNET.ATG" 
out type);
				}
				Expect(1);

#line  781 "VBNET.ATG" 
				EventDeclaration ed = new EventDeclaration(type, mod.Modifier, p, attributes, name, null);
				ed.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				compilationUnit.AddChild(ed);
				ed.EndLocation = t.EndLocation;
				
			} else if (la.kind == 169) {
				lexer.NextToken();

#line  789 "VBNET.ATG" 
				mod.Check(Modifier.InterfaceMethods);
				ArrayList comments = lexer.SpecialTracker.RetreiveComments();
				
				Identifier();

#line  792 "VBNET.ATG" 
				name = t.val; 
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  793 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				Expect(1);

#line  796 "VBNET.ATG" 
				MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, null, p, attributes);
				md.Specials["before"] = comments;
				md.EndLocation = t.EndLocation;
				compilationUnit.AddChild(md);
				
			} else if (la.kind == 101) {
				lexer.NextToken();

#line  804 "VBNET.ATG" 
				mod.Check(Modifier.InterfaceMethods);
				AttributeSection attributeSection = null;
				
				Identifier();

#line  807 "VBNET.ATG" 
				name = t.val; 
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  808 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				if (la.kind == 49) {
					lexer.NextToken();
					if (la.kind == 28) {
						AttributeSection(
#line  809 "VBNET.ATG" 
out attributeSection);
					}
					TypeName(
#line  809 "VBNET.ATG" 
out type);
				}

#line  811 "VBNET.ATG" 
				if(type == null) {
				type = new TypeReference("System.Object");
				}
				type.Attributes = attributeSection;
				MethodDeclaration md = new MethodDeclaration(name, mod.Modifier, type, p, attributes);
				md.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				md.EndLocation = t.EndLocation;
				compilationUnit.AddChild(md);
				
				Expect(1);
			} else if (la.kind == 148) {
				lexer.NextToken();

#line  824 "VBNET.ATG" 
				mod.Check(Modifier.InterfaceProperties);
				ArrayList comments = lexer.SpecialTracker.RetreiveComments();
				
				Identifier();

#line  827 "VBNET.ATG" 
				name = t.val;  
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  828 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				if (la.kind == 49) {
					lexer.NextToken();
					TypeName(
#line  829 "VBNET.ATG" 
out type);
				}

#line  831 "VBNET.ATG" 
				if(type == null) {
				type = new TypeReference("System.Object");
				}
				
				Expect(1);

#line  837 "VBNET.ATG" 
				PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
				pd.Parameters = p;
				pd.Specials["before"] = comments;
				pd.EndLocation = t.EndLocation;
				compilationUnit.AddChild(pd);
				
			} else SynErr(208);
		} else if (StartOf(13)) {
			NonModuleDeclaration(
#line  845 "VBNET.ATG" 
mod, attributes);
		} else SynErr(209);
	}
        public object Visit(MethodDeclaration methodDeclaration, object data)
        {
            DebugOutput(methodDeclaration);
            exitConstructStack.Push(new DictionaryEntry(typeof(MethodDeclaration), null));

            AppendNewLine();
            AppendAttributes(methodDeclaration.Attributes);
            AppendIndentation();
            sourceText.Append(GetModifier(methodDeclaration.Modifier));
            sourceText.Append(GetTypeString(methodDeclaration.TypeReference));
            sourceText.Append(" ");
            sourceText.Append(methodDeclaration.Name);
            sourceText.Append("(");
            AppendParameters(methodDeclaration.Parameters);
            sourceText.Append(")");

            if (currentType.Type != Types.Interface &&
                (methodDeclaration.Modifier & Modifier.MustOverride) != Modifier.MustOverride)
            {
                AppendNewLine();
                AppendIndentation();
                sourceText.Append("{");
                AppendNewLine();
                if (methodDeclaration.Body != null) {
                    ++indentLevel;
                    methodDeclaration.Body.AcceptVisitor(this, data);
                    GenerateExitConstructLabel();
                    --indentLevel;
                }
                AppendIndentation();
                sourceText.Append("}");
            } else {
                sourceText.Append(";");
            }
            AppendNewLine();
            return null;
        }
	void StructureMemberDecl(
#line  884 "VBNET.ATG" 
Modifiers m, ArrayList attributes) {

#line  886 "VBNET.ATG" 
		TypeReference type = null;
		ArrayList p = null;
		Statement stmt = null;
		ArrayList variableDeclarators = new ArrayList();
		
		switch (la.kind) {
		case 68: case 81: case 91: case 113: case 122: case 168: {
			NonModuleDeclaration(
#line  891 "VBNET.ATG" 
m, attributes);
			break;
		}
		case 169: {
			lexer.NextToken();

#line  895 "VBNET.ATG" 
			Point startPos = t.Location;
			ArrayList comments = lexer.SpecialTracker.RetreiveComments();
			
			if (StartOf(9)) {

#line  900 "VBNET.ATG" 
				string name = String.Empty;
				MethodDeclaration methodDeclaration;
				HandlesClause handlesClause = null;
				ImplementsClause implementsClause = null;
				
				Identifier();

#line  907 "VBNET.ATG" 
				name = t.val;
				m.Check(Modifier.Methods);
				
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  910 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				if (la.kind == 106 || la.kind == 108) {
					if (la.kind == 108) {
						ImplementsClause(
#line  913 "VBNET.ATG" 
out implementsClause);
					} else {
						HandlesClause(
#line  915 "VBNET.ATG" 
out handlesClause);
					}
				}

#line  918 "VBNET.ATG" 
				Point endLocation = t.EndLocation; 
				Expect(1);
				if (
#line  922 "VBNET.ATG" 
IsMustOverride(m)) {

#line  924 "VBNET.ATG" 
					methodDeclaration = new MethodDeclaration(name, m.Modifier,  null, p, attributes);
					methodDeclaration.Specials["before"] = comments;
					methodDeclaration.StartLocation = startPos;
					methodDeclaration.EndLocation   = endLocation;
					
					methodDeclaration.HandlesClause = handlesClause;
					methodDeclaration.ImplementsClause = implementsClause;
					
					compilationUnit.AddChild(methodDeclaration);
					
				} else if (StartOf(10)) {

#line  936 "VBNET.ATG" 
					methodDeclaration = new MethodDeclaration(name, m.Modifier,  null, p, attributes);
					methodDeclaration.Specials["before"] = comments;
					methodDeclaration.StartLocation = startPos;
					methodDeclaration.EndLocation   = endLocation;
					
					methodDeclaration.HandlesClause = handlesClause;
					methodDeclaration.ImplementsClause = implementsClause;
					
					compilationUnit.AddChild(methodDeclaration);
					compilationUnit.BlockStart(methodDeclaration);
					
					Block(
#line  947 "VBNET.ATG" 
out stmt);

#line  949 "VBNET.ATG" 
					compilationUnit.BlockEnd();
					methodDeclaration.Body  = (BlockStatement)stmt;
					
					Expect(89);
					Expect(169);

#line  952 "VBNET.ATG" 
					methodDeclaration.Body.EndLocation = t.EndLocation; 
					Expect(1);
				} else SynErr(201);
			} else if (la.kind == 128) {
				lexer.NextToken();
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  955 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}

#line  956 "VBNET.ATG" 
				m.Check(Modifier.Constructors); 

#line  957 "VBNET.ATG" 
				Point constructorEndLocation = t.EndLocation; 
				Expect(1);
				Block(
#line  959 "VBNET.ATG" 
out stmt);
				Expect(89);
				Expect(169);

#line  960 "VBNET.ATG" 
				Point endLocation = t.EndLocation; 
				Expect(1);

#line  962 "VBNET.ATG" 
				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes); 
				cd.StartLocation = startPos;
				cd.Specials["before"] = comments;
				cd.EndLocation   = constructorEndLocation;
				cd.Body = (BlockStatement)stmt;
				cd.Body.EndLocation   = endLocation;
				compilationUnit.AddChild(cd);
				
			} else SynErr(202);
			break;
		}
		case 101: {
			lexer.NextToken();

#line  975 "VBNET.ATG" 
			m.Check(Modifier.Methods);
			string name = String.Empty;
			Point startPos = t.Location;
			MethodDeclaration methodDeclaration;
			HandlesClause handlesClause = null;
			ImplementsClause implementsClause = null;
			AttributeSection attributeSection = null;
			
			Identifier();

#line  983 "VBNET.ATG" 
			name = t.val; 
			if (la.kind == 25) {
				lexer.NextToken();
				if (StartOf(4)) {
					FormalParameterList(
#line  984 "VBNET.ATG" 
out p);
				}
				Expect(26);
			}
			if (la.kind == 49) {
				lexer.NextToken();
				if (la.kind == 28) {
					AttributeSection(
#line  985 "VBNET.ATG" 
out attributeSection);
				}
				TypeName(
#line  985 "VBNET.ATG" 
out type);
			}

#line  987 "VBNET.ATG" 
			if(type == null) {
			type = new TypeReference("System.Object");
			}
			type.Attributes = attributeSection;
			
			if (la.kind == 106 || la.kind == 108) {
				if (la.kind == 108) {
					ImplementsClause(
#line  994 "VBNET.ATG" 
out implementsClause);
				} else {
					HandlesClause(
#line  996 "VBNET.ATG" 
out handlesClause);
				}
			}
			Expect(1);
			if (
#line  1002 "VBNET.ATG" 
IsMustOverride(m)) {

#line  1004 "VBNET.ATG" 
				methodDeclaration = new MethodDeclaration(name, m.Modifier,  type, p, attributes);
				methodDeclaration.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				methodDeclaration.StartLocation = startPos;
				methodDeclaration.EndLocation   = t.EndLocation;
				methodDeclaration.HandlesClause = handlesClause;
				methodDeclaration.ImplementsClause = implementsClause;
				compilationUnit.AddChild(methodDeclaration);
				
			} else if (StartOf(10)) {

#line  1014 "VBNET.ATG" 
				methodDeclaration = new MethodDeclaration(name, m.Modifier,  type, p, attributes);
				methodDeclaration.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				methodDeclaration.StartLocation = startPos;
				methodDeclaration.EndLocation   = t.EndLocation;
				
				methodDeclaration.HandlesClause = handlesClause;
				methodDeclaration.ImplementsClause = implementsClause;
				
				compilationUnit.AddChild(methodDeclaration);
				compilationUnit.BlockStart(methodDeclaration);
				
				Block(
#line  1025 "VBNET.ATG" 
out stmt);

#line  1027 "VBNET.ATG" 
				compilationUnit.BlockEnd();
				methodDeclaration.Body  = (BlockStatement)stmt;
				
				Expect(89);
				Expect(101);

#line  1032 "VBNET.ATG" 
				methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
				methodDeclaration.Body.EndLocation   = t.EndLocation;
				
				Expect(1);
			} else SynErr(203);
			break;
		}
		case 79: {
			lexer.NextToken();

#line  1041 "VBNET.ATG" 
			m.Check(Modifier.ExternalMethods);
			Point startPos = t.Location;
			CharsetModifier charsetModifer = CharsetModifier.None;
			string library = String.Empty;
			string alias = null;
			string name = String.Empty;
			
			if (StartOf(11)) {
				Charset(
#line  1048 "VBNET.ATG" 
out charsetModifer);
			}
			if (la.kind == 169) {
				lexer.NextToken();
				Identifier();

#line  1051 "VBNET.ATG" 
				name = t.val; 
				Expect(116);
				Expect(3);

#line  1052 "VBNET.ATG" 
				library = t.val; 
				if (la.kind == 45) {
					lexer.NextToken();
					Expect(3);

#line  1053 "VBNET.ATG" 
					alias = t.val; 
				}
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  1054 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				Expect(1);

#line  1057 "VBNET.ATG" 
				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
				declareDeclaration.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				declareDeclaration.StartLocation = startPos;
				declareDeclaration.EndLocation   = t.EndLocation;
				compilationUnit.AddChild(declareDeclaration);
				
			} else if (la.kind == 101) {
				lexer.NextToken();
				Identifier();

#line  1065 "VBNET.ATG" 
				name = t.val; 
				Expect(116);
				Expect(3);

#line  1066 "VBNET.ATG" 
				library = t.val; 
				if (la.kind == 45) {
					lexer.NextToken();
					Expect(3);

#line  1067 "VBNET.ATG" 
					alias = t.val; 
				}
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  1068 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
				if (la.kind == 49) {
					lexer.NextToken();
					TypeName(
#line  1069 "VBNET.ATG" 
out type);
				}
				Expect(1);

#line  1072 "VBNET.ATG" 
				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
				declareDeclaration.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				declareDeclaration.StartLocation = startPos;
				declareDeclaration.EndLocation   = t.EndLocation;
				compilationUnit.AddChild(declareDeclaration);
				
			} else SynErr(204);
			break;
		}
		case 94: {
			lexer.NextToken();

#line  1083 "VBNET.ATG" 
			m.Check(Modifier.Events);
			Point startPos = t.Location;
			EventDeclaration eventDeclaration;
			string name = String.Empty;
			ImplementsClause implementsClause = null;
			
			Identifier();

#line  1089 "VBNET.ATG" 
			name= t.val; 
			if (la.kind == 49) {
				lexer.NextToken();
				TypeName(
#line  1091 "VBNET.ATG" 
out type);
			} else if (la.kind == 1 || la.kind == 25 || la.kind == 108) {
				if (la.kind == 25) {
					lexer.NextToken();
					if (StartOf(4)) {
						FormalParameterList(
#line  1093 "VBNET.ATG" 
out p);
					}
					Expect(26);
				}
			} else SynErr(205);
			if (la.kind == 108) {
				ImplementsClause(
#line  1095 "VBNET.ATG" 
out implementsClause);
			}

#line  1097 "VBNET.ATG" 
			eventDeclaration = new EventDeclaration(type, m.Modifier, p, attributes, name, implementsClause);
			eventDeclaration.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
			eventDeclaration.StartLocation = startPos;
			eventDeclaration.EndLocation = t.EndLocation;
			compilationUnit.AddChild(eventDeclaration);
			
			Expect(1);
			break;
		}
		case 2: case 52: case 71: case 171: {

#line  1105 "VBNET.ATG" 
			Point startPos = t.Location; 

#line  1107 "VBNET.ATG" 
			m.Check(Modifier.Fields);
			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
			ArrayList comments = lexer.SpecialTracker.RetreiveComments();
			fd.StartLocation = startPos;
			
			VariableDeclarator(
#line  1112 "VBNET.ATG" 
variableDeclarators);

#line  1114 "VBNET.ATG" 
			((INode)variableDeclarators[0]).Specials["before"] = comments;
			
			while (la.kind == 12) {
				lexer.NextToken();
				VariableDeclarator(
#line  1116 "VBNET.ATG" 
variableDeclarators);
			}
			Expect(1);

#line  1119 "VBNET.ATG" 
			fd.EndLocation = t.EndLocation;
			fd.Fields = variableDeclarators;
			compilationUnit.AddChild(fd);
			
			break;
		}
		case 72: {

#line  1124 "VBNET.ATG" 
			m.Check(Modifier.Fields); 
			lexer.NextToken();

#line  1125 "VBNET.ATG" 
			m.Add(Modifier.Constant);  

#line  1127 "VBNET.ATG" 
			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
			fd.StartLocation = t.Location;
			ArrayList comments = lexer.SpecialTracker.RetreiveComments();
			ArrayList constantDeclarators = new ArrayList();
			
			ConstantDeclarator(
#line  1132 "VBNET.ATG" 
constantDeclarators);

#line  1134 "VBNET.ATG" 
			((INode)constantDeclarators[0]).Specials["before"] = comments;
			
			while (la.kind == 12) {
				lexer.NextToken();
				ConstantDeclarator(
#line  1136 "VBNET.ATG" 
constantDeclarators);
			}

#line  1138 "VBNET.ATG" 
			fd.Fields = constantDeclarators;
			fd.EndLocation = t.Location;
			
			Expect(1);

#line  1143 "VBNET.ATG" 
			fd.EndLocation = t.EndLocation;
			compilationUnit.AddChild(fd);
			
			break;
		}
		case 148: {
			lexer.NextToken();

#line  1149 "VBNET.ATG" 
			m.Check(Modifier.Properties);
			Point startPos = t.Location;
			ImplementsClause implementsClause = null;
			
			Identifier();

#line  1153 "VBNET.ATG" 
			string propertyName = t.val; 
			if (la.kind == 25) {
				lexer.NextToken();
				if (StartOf(4)) {
					FormalParameterList(
#line  1154 "VBNET.ATG" 
out p);
				}
				Expect(26);
			}
			if (la.kind == 49) {
				lexer.NextToken();
				TypeName(
#line  1155 "VBNET.ATG" 
out type);
			}

#line  1157 "VBNET.ATG" 
			if(type == null) {
			type = new TypeReference("System.Object");
			}
			
			if (la.kind == 108) {
				ImplementsClause(
#line  1161 "VBNET.ATG" 
out implementsClause);
			}
			Expect(1);
			if (
#line  1165 "VBNET.ATG" 
IsMustOverride(m)) {

#line  1167 "VBNET.ATG" 
				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
				pDecl.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				pDecl.StartLocation = startPos;
				pDecl.EndLocation   = t.Location;
				pDecl.TypeReference = type;
				pDecl.ImplementsClause = implementsClause;
				pDecl.Parameters = p;
				compilationUnit.AddChild(pDecl);
				
			} else if (la.kind == 28 || la.kind == 102 || la.kind == 158) {

#line  1178 "VBNET.ATG" 
				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
				pDecl.Specials["before"] = lexer.SpecialTracker.RetreiveComments();
				pDecl.StartLocation = startPos;
				pDecl.EndLocation   = t.Location;
				pDecl.BodyStart   = t.Location;
				pDecl.TypeReference = type;
				pDecl.ImplementsClause = implementsClause;
				pDecl.Parameters = p;
				PropertyGetRegion getRegion;
				PropertySetRegion setRegion;
				
				AccessorDecls(
#line  1189 "VBNET.ATG" 
out getRegion, out setRegion);
				Expect(89);
				Expect(148);
				Expect(1);

#line  1193 "VBNET.ATG" 
				pDecl.GetRegion = getRegion;
				pDecl.SetRegion = setRegion;
				pDecl.BodyEnd = t.EndLocation;
				compilationUnit.AddChild(pDecl);
				
			} else SynErr(206);
			break;
		}
		default: SynErr(207); break;
		}
	}
        public virtual object Visit(MethodDeclaration methodDeclaration, object data)
        {
            blockStack.Push(methodDeclaration.Body);
            foreach (AttributeSection a in methodDeclaration.Attributes) {
                a.AcceptVisitor(this, data);
            }
            if (methodDeclaration.TypeReference != null) {
                methodDeclaration.TypeReference.AcceptVisitor(this, data);
            }

            if (methodDeclaration.Parameters != null) {
                foreach (ParameterDeclarationExpression p in methodDeclaration.Parameters) {
                    p.AcceptVisitor(this, data);
                }
            }

            if (methodDeclaration.HandlesClause != null) {
                methodDeclaration.HandlesClause.AcceptVisitor(this, data);
            }
            if (methodDeclaration.ImplementsClause != null) {
                methodDeclaration.ImplementsClause.AcceptVisitor(this, data);
            }
            object ret = null;
            if (methodDeclaration.Body != null) {
                methodDeclaration.Body.AcceptChildren(this, data);
            }
            blockStack.Pop();
            return ret;
        }