[Monodevelop-patches-list] r2402 - in trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory: . src/Parser/AST/TypeLevel src/Parser/generated src/PrettyPrinter

John Luke <jluke@cfl.rr.com> jluke at mono-cvs.ximian.com
Wed Mar 30 18:08:25 EST 2005


Author: jluke
Date: 2005-03-30 18:08:24 -0500 (Wed, 30 Mar 2005)
New Revision: 2402

Modified:
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/ChangeLog
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/Makefile.am
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertyGetRegion.cs
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertySetRegion.cs
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/Parser.cs
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/cs.ATG
   trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/PrettyPrinter/PrettyPrintVisitor.cs
Log:
allow C# 2 property get and set modifiers


Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/ChangeLog
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/ChangeLog	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/ChangeLog	2005-03-30 23:08:24 UTC (rev 2402)
@@ -1,3 +1,12 @@
+2005-03-30  John Luke  <john.luke at gmail.com>
+
+	* src/PrettyPrinter/PrettyPrintVisitor.cs:
+	* src/Parser/AST/TypeLevel/PropertyGetRegion.cs:
+	* src/Parser/AST/TypeLevel/PropertySetRegion.cs:
+	* src/Parser/generated/cs.ATG:
+	* src/Parser/generated/Parser.cs: allow Modifiers
+	on property get and set
+
 2005-03-26  John Luke  <john.luke at gmail.com>
 
 	* src/PrettyPrinter/PrettyPrintVisitor.cs

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/Makefile.am
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/Makefile.am	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/Makefile.am	2005-03-30 23:08:24 UTC (rev 2402)
@@ -134,6 +134,9 @@
 run-tests: $(TEST)
 	MONO_PATH=../../../build/bin mono $(TEST) ./tests
 
+run-mcs-tests: $(TEST)
+	MONO_PATH=../../../build/bin mono $(TEST) ../../../../mcs/tests
+
 assemblydir = $(libdir)/monodevelop/bin
 assembly_DATA = $(DLL)
 

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertyGetRegion.cs
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertyGetRegion.cs	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertyGetRegion.cs	2005-03-30 23:08:24 UTC (rev 2402)
@@ -22,6 +22,7 @@
 {
 	public class PropertyGetRegion : AbstractNode
 	{
+		Modifier modifier;
 		BlockStatement block;
 		ArrayList      attributes;
 		
@@ -33,6 +34,12 @@
 				block = value;
 			}
 		}
+
+		public Modifier Modifier {
+			get { return modifier; }
+			set { modifier = value; }
+		}
+
 		public ArrayList Attributes {
 			get {
 				return attributes;
@@ -42,10 +49,15 @@
 			}
 		}
 		
-		public PropertyGetRegion(BlockStatement block, ArrayList attributes)
+		public PropertyGetRegion(BlockStatement block, ArrayList attributes) : this (block, attributes, Modifier.None)
 		{
+		}
+
+		public PropertyGetRegion(BlockStatement block, ArrayList attributes, Modifier m)
+		{
 			this.block = block;
 			this.attributes = attributes;
+			this.modifier = m;
 		}
 		
 		public override object AcceptVisitor(IASTVisitor visitor, object data)

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertySetRegion.cs
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertySetRegion.cs	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/AST/TypeLevel/PropertySetRegion.cs	2005-03-30 23:08:24 UTC (rev 2402)
@@ -22,6 +22,7 @@
 {
 	public class PropertySetRegion : AbstractNode
 	{
+		Modifier modifier;
 		BlockStatement block;
 		ArrayList      attributes;
 		
@@ -33,6 +34,11 @@
 				block = value;
 			}
 		}
+
+		public Modifier Modifier {
+			get { return modifier; }
+			set { modifier = value; }
+		}
 		
 		public ArrayList Attributes {
 			get {
@@ -43,10 +49,15 @@
 			}
 		}
 			
-		public PropertySetRegion(BlockStatement block, ArrayList attributes)
+		public PropertySetRegion(BlockStatement block, ArrayList attributes) : this (block, attributes, Modifier.None)
 		{
+		}
+
+		public PropertySetRegion(BlockStatement block, ArrayList attributes, Modifier m)
+		{
 			this.block = block;
 			this.attributes = attributes;
+			this.modifier = m;
 		}
 		
 		public override object AcceptVisitor(IASTVisitor visitor, object data)

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/Parser.cs
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/Parser.cs	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/Parser.cs	2005-03-30 23:08:24 UTC (rev 2402)
@@ -730,43 +730,43 @@
 	}
 
 	void Expr(
-#line  1715 "cs.ATG" 
+#line  1727 "cs.ATG" 
 out Expression expr) {
 
-#line  1716 "cs.ATG" 
+#line  1728 "cs.ATG" 
 		expr = null; Expression expr1 = null, expr2 = null; 
 		UnaryExpr(
-#line  1718 "cs.ATG" 
+#line  1730 "cs.ATG" 
 out expr);
 		if (StartOf(5)) {
 			ConditionalOrExpr(
-#line  1721 "cs.ATG" 
+#line  1733 "cs.ATG" 
 ref expr);
 			if (la.kind == 11) {
 				lexer.NextToken();
 				Expr(
-#line  1721 "cs.ATG" 
+#line  1733 "cs.ATG" 
 out expr1);
 				Expect(9);
 				Expr(
-#line  1721 "cs.ATG" 
+#line  1733 "cs.ATG" 
 out expr2);
 
-#line  1721 "cs.ATG" 
+#line  1733 "cs.ATG" 
 				expr = new ConditionalExpression(expr, expr1, expr2);  
 			}
 		} else if (StartOf(6)) {
 
-#line  1723 "cs.ATG" 
+#line  1735 "cs.ATG" 
 			AssignmentOperatorType op; Expression val; 
 			AssignmentOperator(
-#line  1723 "cs.ATG" 
+#line  1735 "cs.ATG" 
 out op);
 			Expr(
-#line  1723 "cs.ATG" 
+#line  1735 "cs.ATG" 
 out val);
 
-#line  1723 "cs.ATG" 
+#line  1735 "cs.ATG" 
 			expr = new AssignmentExpression(expr, op, val); 
 		} else SynErr(128);
 	}
@@ -1628,23 +1628,23 @@
 	}
 
 	void ClassMemberDecl(
-#line  1179 "cs.ATG" 
+#line  1187 "cs.ATG" 
 Modifiers m, ArrayList attributes) {
 
-#line  1180 "cs.ATG" 
+#line  1188 "cs.ATG" 
 		Statement stmt = null; 
 		if (StartOf(16)) {
 			StructMemberDecl(
-#line  1182 "cs.ATG" 
+#line  1190 "cs.ATG" 
 m, attributes);
 		} else if (la.kind == 25) {
 
-#line  1183 "cs.ATG" 
+#line  1191 "cs.ATG" 
 			m.Check(Modifier.Destructors); Point startPos = t.Location; 
 			lexer.NextToken();
 			Expect(1);
 
-#line  1184 "cs.ATG" 
+#line  1192 "cs.ATG" 
 			DestructorDeclaration d = new DestructorDeclaration(t.val, attributes); 
 			d.Modifier = m.Modifier;
 			d.StartLocation = startPos;
@@ -1653,13 +1653,13 @@
 			Expect(19);
 			if (la.kind == 14) {
 				Block(
-#line  1188 "cs.ATG" 
+#line  1196 "cs.ATG" 
 out stmt);
 			} else if (la.kind == 10) {
 				lexer.NextToken();
 			} else SynErr(139);
 
-#line  1188 "cs.ATG" 
+#line  1196 "cs.ATG" 
 			d.EndLocation = t.EndLocation; 
 			d.Body = (BlockStatement)stmt;
 			compilationUnit.AddChild(d);
@@ -1668,10 +1668,10 @@
 	}
 
 	void StructMemberDecl(
-#line  971 "cs.ATG" 
+#line  979 "cs.ATG" 
 Modifiers m, ArrayList attributes) {
 
-#line  973 "cs.ATG" 
+#line  981 "cs.ATG" 
 		string qualident = null;
 		TypeReference type;
 		Expression expr;
@@ -1681,68 +1681,68 @@
 		
 		if (la.kind == 59) {
 
-#line  981 "cs.ATG" 
+#line  989 "cs.ATG" 
 			m.Check(Modifier.Constants); 
 			lexer.NextToken();
 			Type(
-#line  983 "cs.ATG" 
+#line  991 "cs.ATG" 
 out type);
 			Expect(1);
 
-#line  983 "cs.ATG" 
+#line  991 "cs.ATG" 
 			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier | Modifier.Const);
 			VariableDeclaration f = new VariableDeclaration(t.val);
 			fd.Fields.Add(f);
 			
 			Expect(3);
 			Expr(
-#line  987 "cs.ATG" 
+#line  995 "cs.ATG" 
 out expr);
 
-#line  987 "cs.ATG" 
+#line  995 "cs.ATG" 
 			f.Initializer = expr; 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  988 "cs.ATG" 
+#line  996 "cs.ATG" 
 				f = new VariableDeclaration(t.val);
 				fd.Fields.Add(f);
 				
 				Expect(3);
 				Expr(
-#line  991 "cs.ATG" 
+#line  999 "cs.ATG" 
 out expr);
 
-#line  991 "cs.ATG" 
+#line  999 "cs.ATG" 
 				f.Initializer = expr; 
 			}
 			Expect(10);
 
-#line  992 "cs.ATG" 
+#line  1000 "cs.ATG" 
 			fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); 
 		} else if (
-#line  995 "cs.ATG" 
+#line  1003 "cs.ATG" 
 NotVoidPointer()) {
 
-#line  995 "cs.ATG" 
+#line  1003 "cs.ATG" 
 			m.Check(Modifier.PropertysEventsMethods); 
 			Expect(122);
 
-#line  996 "cs.ATG" 
+#line  1004 "cs.ATG" 
 			Point startPos = t.Location; 
 			Qualident(
-#line  997 "cs.ATG" 
+#line  1005 "cs.ATG" 
 out qualident);
 			Expect(18);
 			if (StartOf(9)) {
 				FormalParameterList(
-#line  998 "cs.ATG" 
+#line  1006 "cs.ATG" 
 out p);
 			}
 			Expect(19);
 
-#line  998 "cs.ATG" 
+#line  1006 "cs.ATG" 
 			MethodDeclaration methodDeclaration = new MethodDeclaration(qualident, 
 			                                                           m.Modifier, 
 			                                                           new TypeReference("void"), 
@@ -1755,23 +1755,23 @@
 			
 			if (la.kind == 14) {
 				Block(
-#line  1008 "cs.ATG" 
+#line  1016 "cs.ATG" 
 out stmt);
 			} else if (la.kind == 10) {
 				lexer.NextToken();
 			} else SynErr(141);
 
-#line  1008 "cs.ATG" 
+#line  1016 "cs.ATG" 
 			compilationUnit.BlockEnd();
 			methodDeclaration.Body  = (BlockStatement)stmt;
 			
 		} else if (la.kind == 68) {
 
-#line  1012 "cs.ATG" 
+#line  1020 "cs.ATG" 
 			m.Check(Modifier.PropertysEventsMethods); 
 			lexer.NextToken();
 
-#line  1013 "cs.ATG" 
+#line  1021 "cs.ATG" 
 			EventDeclaration eventDecl = new EventDeclaration(m.Modifier, attributes);
 			eventDecl.StartLocation = t.Location;
 			compilationUnit.AddChild(eventDecl);
@@ -1780,102 +1780,102 @@
 			EventRemoveRegion removeBlock = null;
 			
 			Type(
-#line  1020 "cs.ATG" 
+#line  1028 "cs.ATG" 
 out type);
 
-#line  1020 "cs.ATG" 
+#line  1028 "cs.ATG" 
 			eventDecl.TypeReference = type; 
 			if (
-#line  1022 "cs.ATG" 
+#line  1030 "cs.ATG" 
 IsVarDecl()) {
 				VariableDeclarator(
-#line  1022 "cs.ATG" 
+#line  1030 "cs.ATG" 
 variableDeclarators);
 				while (la.kind == 12) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  1023 "cs.ATG" 
+#line  1031 "cs.ATG" 
 variableDeclarators);
 				}
 				Expect(10);
 
-#line  1023 "cs.ATG" 
+#line  1031 "cs.ATG" 
 				eventDecl.VariableDeclarators = variableDeclarators; eventDecl.EndLocation = t.EndLocation;  
 			} else if (la.kind == 1) {
 				Qualident(
-#line  1024 "cs.ATG" 
+#line  1032 "cs.ATG" 
 out qualident);
 
-#line  1024 "cs.ATG" 
+#line  1032 "cs.ATG" 
 				eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation;  
 				Expect(14);
 
-#line  1025 "cs.ATG" 
+#line  1033 "cs.ATG" 
 				eventDecl.BodyStart = t.Location; 
 				EventAccessorDecls(
-#line  1026 "cs.ATG" 
+#line  1034 "cs.ATG" 
 out addBlock, out removeBlock);
 				Expect(15);
 
-#line  1027 "cs.ATG" 
+#line  1035 "cs.ATG" 
 				eventDecl.BodyEnd   = t.EndLocation; 
 			} else SynErr(142);
 
-#line  1028 "cs.ATG" 
+#line  1036 "cs.ATG" 
 			compilationUnit.BlockEnd();
 				                                           eventDecl.AddRegion = addBlock;
 			eventDecl.RemoveRegion = removeBlock;
 			
 		} else if (
-#line  1035 "cs.ATG" 
+#line  1043 "cs.ATG" 
 IdentAndLPar()) {
 
-#line  1035 "cs.ATG" 
+#line  1043 "cs.ATG" 
 			m.Check(Modifier.Constructors | Modifier.StaticConstructors); 
 			Expect(1);
 
-#line  1036 "cs.ATG" 
+#line  1044 "cs.ATG" 
 			string name = t.val; Point startPos = t.Location; 
 			Expect(18);
 			if (StartOf(9)) {
 
-#line  1036 "cs.ATG" 
+#line  1044 "cs.ATG" 
 				m.Check(Modifier.Constructors); 
 				FormalParameterList(
-#line  1037 "cs.ATG" 
+#line  1045 "cs.ATG" 
 out p);
 			}
 			Expect(19);
 
-#line  1039 "cs.ATG" 
+#line  1047 "cs.ATG" 
 			ConstructorInitializer init = null;  
 			if (la.kind == 9) {
 
-#line  1040 "cs.ATG" 
+#line  1048 "cs.ATG" 
 				m.Check(Modifier.Constructors); 
 				ConstructorInitializer(
-#line  1041 "cs.ATG" 
+#line  1049 "cs.ATG" 
 out init);
 			}
 
-#line  1043 "cs.ATG" 
+#line  1051 "cs.ATG" 
 			ConstructorDeclaration cd = new ConstructorDeclaration(name, m.Modifier, p, init, attributes); 
 			cd.StartLocation = startPos;
 			cd.EndLocation   = t.EndLocation;
 			
 			if (la.kind == 14) {
 				Block(
-#line  1048 "cs.ATG" 
+#line  1056 "cs.ATG" 
 out stmt);
 			} else if (la.kind == 10) {
 				lexer.NextToken();
 			} else SynErr(143);
 
-#line  1048 "cs.ATG" 
+#line  1056 "cs.ATG" 
 			cd.Body = (BlockStatement)stmt; compilationUnit.AddChild(cd); 
 		} else if (la.kind == 69 || la.kind == 79) {
 
-#line  1051 "cs.ATG" 
+#line  1059 "cs.ATG" 
 			m.Check(Modifier.Operators);
 			if (m.isNone) Error("at least one modifier must be set"); 
 			bool isImplicit = true;
@@ -1885,37 +1885,37 @@
 			} else {
 				lexer.NextToken();
 
-#line  1055 "cs.ATG" 
+#line  1063 "cs.ATG" 
 				isImplicit = false; 
 			}
 			Expect(91);
 			Type(
-#line  1056 "cs.ATG" 
+#line  1064 "cs.ATG" 
 out type);
 
-#line  1056 "cs.ATG" 
+#line  1064 "cs.ATG" 
 			TypeReference operatorType = type; 
 			Expect(18);
 			Type(
-#line  1057 "cs.ATG" 
+#line  1065 "cs.ATG" 
 out type);
 			Expect(1);
 
-#line  1057 "cs.ATG" 
+#line  1065 "cs.ATG" 
 			string varName = t.val; 
 			Expect(19);
 			if (la.kind == 14) {
 				Block(
-#line  1057 "cs.ATG" 
+#line  1065 "cs.ATG" 
 out stmt);
 			} else if (la.kind == 10) {
 				lexer.NextToken();
 
-#line  1057 "cs.ATG" 
+#line  1065 "cs.ATG" 
 				stmt = null; 
 			} else SynErr(144);
 
-#line  1060 "cs.ATG" 
+#line  1068 "cs.ATG" 
 			OperatorDeclarator operatorDeclarator = new OperatorDeclarator(isImplicit ? OperatorType.Implicit : OperatorType.Explicit,
 			                                                              operatorType,
 			                                                              type,
@@ -1926,54 +1926,54 @@
 			
 		} else if (StartOf(17)) {
 			TypeDecl(
-#line  1070 "cs.ATG" 
+#line  1078 "cs.ATG" 
 m, attributes);
 		} else if (StartOf(8)) {
 			Type(
-#line  1071 "cs.ATG" 
+#line  1079 "cs.ATG" 
 out type);
 
-#line  1071 "cs.ATG" 
+#line  1079 "cs.ATG" 
 			Point startPos = t.Location; 
 			if (la.kind == 91) {
 
-#line  1073 "cs.ATG" 
+#line  1081 "cs.ATG" 
 				Token op;
 				m.Check(Modifier.Operators);
 				if (m.isNone) Error("at least one modifier must be set");
 				
 				lexer.NextToken();
 				OverloadableOperator(
-#line  1077 "cs.ATG" 
+#line  1085 "cs.ATG" 
 out op);
 
-#line  1077 "cs.ATG" 
+#line  1085 "cs.ATG" 
 				TypeReference firstType, secondType = null; string secondName = null; 
 				Expect(18);
 				Type(
-#line  1078 "cs.ATG" 
+#line  1086 "cs.ATG" 
 out firstType);
 				Expect(1);
 
-#line  1078 "cs.ATG" 
+#line  1086 "cs.ATG" 
 				string firstName = t.val; 
 				if (la.kind == 12) {
 					lexer.NextToken();
 					Type(
-#line  1079 "cs.ATG" 
+#line  1087 "cs.ATG" 
 out secondType);
 					Expect(1);
 
-#line  1079 "cs.ATG" 
+#line  1087 "cs.ATG" 
 					secondName = t.val; 
 
-#line  1079 "cs.ATG" 
+#line  1087 "cs.ATG" 
 					if (ParserUtil.IsUnaryOperator(op) && !ParserUtil.IsBinaryOperator(op))
 					Error("too many operands for unary operator"); 
 					
 				} else if (la.kind == 19) {
 
-#line  1082 "cs.ATG" 
+#line  1090 "cs.ATG" 
 					if (ParserUtil.IsBinaryOperator(op))
 					Error("too few operands for binary operator");
 					
@@ -1981,13 +1981,13 @@
 				Expect(19);
 				if (la.kind == 14) {
 					Block(
-#line  1086 "cs.ATG" 
+#line  1094 "cs.ATG" 
 out stmt);
 				} else if (la.kind == 10) {
 					lexer.NextToken();
 				} else SynErr(146);
 
-#line  1088 "cs.ATG" 
+#line  1096 "cs.ATG" 
 				OperatorDeclarator operatorDeclarator = new OperatorDeclarator(secondType != null ? OperatorType.Binary : OperatorType.Unary, 
 				                                                              type,
 				                                                              op.kind,
@@ -2000,43 +2000,43 @@
 				compilationUnit.AddChild(operatorDeclaration);
 				
 			} else if (
-#line  1101 "cs.ATG" 
+#line  1109 "cs.ATG" 
 IsVarDecl()) {
 
-#line  1101 "cs.ATG" 
+#line  1109 "cs.ATG" 
 				m.Check(Modifier.Fields); 
 				FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
 				fd.StartLocation = startPos; 
 				
 				VariableDeclarator(
-#line  1105 "cs.ATG" 
+#line  1113 "cs.ATG" 
 variableDeclarators);
 				while (la.kind == 12) {
 					lexer.NextToken();
 					VariableDeclarator(
-#line  1106 "cs.ATG" 
+#line  1114 "cs.ATG" 
 variableDeclarators);
 				}
 				Expect(10);
 
-#line  1107 "cs.ATG" 
+#line  1115 "cs.ATG" 
 				fd.EndLocation = t.EndLocation; fd.Fields = variableDeclarators; compilationUnit.AddChild(fd); 
 			} else if (la.kind == 110) {
 
-#line  1110 "cs.ATG" 
+#line  1118 "cs.ATG" 
 				m.Check(Modifier.Indexers); 
 				lexer.NextToken();
 				Expect(16);
 				FormalParameterList(
-#line  1111 "cs.ATG" 
+#line  1119 "cs.ATG" 
 out p);
 				Expect(17);
 
-#line  1111 "cs.ATG" 
+#line  1119 "cs.ATG" 
 				Point endLocation = t.EndLocation; 
 				Expect(14);
 
-#line  1112 "cs.ATG" 
+#line  1120 "cs.ATG" 
 				IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
 				indexer.StartLocation = startPos;
 				indexer.EndLocation   = endLocation;
@@ -2045,11 +2045,11 @@
 				PropertySetRegion setRegion;
 				
 				AccessorDecls(
-#line  1119 "cs.ATG" 
+#line  1127 "cs.ATG" 
 out getRegion, out setRegion);
 				Expect(15);
 
-#line  1120 "cs.ATG" 
+#line  1128 "cs.ATG" 
 				indexer.BodyEnd    = t.EndLocation;
 				indexer.GetRegion = getRegion;
 				indexer.SetRegion = setRegion;
@@ -2057,25 +2057,25 @@
 				
 			} else if (la.kind == 1) {
 				Qualident(
-#line  1125 "cs.ATG" 
+#line  1133 "cs.ATG" 
 out qualident);
 
-#line  1125 "cs.ATG" 
+#line  1133 "cs.ATG" 
 				Point qualIdentEndLocation = t.EndLocation; 
 				if (la.kind == 14 || la.kind == 18) {
 					if (la.kind == 18) {
 
-#line  1128 "cs.ATG" 
+#line  1136 "cs.ATG" 
 						m.Check(Modifier.PropertysEventsMethods); 
 						lexer.NextToken();
 						if (StartOf(9)) {
 							FormalParameterList(
-#line  1129 "cs.ATG" 
+#line  1137 "cs.ATG" 
 out p);
 						}
 						Expect(19);
 
-#line  1129 "cs.ATG" 
+#line  1137 "cs.ATG" 
 						MethodDeclaration methodDeclaration = new MethodDeclaration(qualident, 
 						                                                     m.Modifier, 
 						                                                     type, 
@@ -2087,18 +2087,18 @@
 						  
 						if (la.kind == 14) {
 							Block(
-#line  1138 "cs.ATG" 
+#line  1146 "cs.ATG" 
 out stmt);
 						} else if (la.kind == 10) {
 							lexer.NextToken();
 						} else SynErr(147);
 
-#line  1138 "cs.ATG" 
+#line  1146 "cs.ATG" 
 						methodDeclaration.Body  = (BlockStatement)stmt; 
 					} else {
 						lexer.NextToken();
 
-#line  1141 "cs.ATG" 
+#line  1149 "cs.ATG" 
 						PropertyDeclaration pDecl = new PropertyDeclaration(qualident, type, m.Modifier, attributes); 
 						pDecl.StartLocation = startPos;
 						pDecl.EndLocation   = qualIdentEndLocation;
@@ -2107,11 +2107,11 @@
 						PropertySetRegion setRegion;
 						
 						AccessorDecls(
-#line  1148 "cs.ATG" 
+#line  1156 "cs.ATG" 
 out getRegion, out setRegion);
 						Expect(15);
 
-#line  1150 "cs.ATG" 
+#line  1158 "cs.ATG" 
 						pDecl.GetRegion = getRegion;
 						pDecl.SetRegion = setRegion;
 						pDecl.BodyEnd = t.EndLocation;
@@ -2120,17 +2120,17 @@
 					}
 				} else if (la.kind == 13) {
 
-#line  1158 "cs.ATG" 
+#line  1166 "cs.ATG" 
 					m.Check(Modifier.Indexers); 
 					lexer.NextToken();
 					Expect(110);
 					Expect(16);
 					FormalParameterList(
-#line  1159 "cs.ATG" 
+#line  1167 "cs.ATG" 
 out p);
 					Expect(17);
 
-#line  1160 "cs.ATG" 
+#line  1168 "cs.ATG" 
 					IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
 					indexer.StartLocation = startPos;
 					indexer.EndLocation   = t.EndLocation;
@@ -2140,14 +2140,14 @@
 					
 					Expect(14);
 
-#line  1167 "cs.ATG" 
+#line  1175 "cs.ATG" 
 					Point bodyStart = t.Location; 
 					AccessorDecls(
-#line  1168 "cs.ATG" 
+#line  1176 "cs.ATG" 
 out getRegion, out setRegion);
 					Expect(15);
 
-#line  1169 "cs.ATG" 
+#line  1177 "cs.ATG" 
 					indexer.BodyStart = bodyStart;
 					indexer.BodyEnd   = t.EndLocation;
 					indexer.GetRegion = getRegion;
@@ -2161,7 +2161,7 @@
 
 	void InterfaceMemberDecl() {
 
-#line  1196 "cs.ATG" 
+#line  1204 "cs.ATG" 
 		TypeReference type;
 		ArrayList p;
 		AttributeSection section;
@@ -2175,39 +2175,39 @@
 		
 		while (la.kind == 16) {
 			AttributeSection(
-#line  1208 "cs.ATG" 
+#line  1216 "cs.ATG" 
 out section);
 
-#line  1208 "cs.ATG" 
+#line  1216 "cs.ATG" 
 			attributes.Add(section); 
 		}
 		if (la.kind == 88) {
 			lexer.NextToken();
 
-#line  1209 "cs.ATG" 
+#line  1217 "cs.ATG" 
 			mod = Modifier.New; startLocation = t.Location; 
 		}
 		if (
-#line  1212 "cs.ATG" 
+#line  1220 "cs.ATG" 
 NotVoidPointer()) {
 			Expect(122);
 
-#line  1212 "cs.ATG" 
+#line  1220 "cs.ATG" 
 			if (startLocation.X == -1) startLocation = t.Location; 
 			Expect(1);
 
-#line  1212 "cs.ATG" 
+#line  1220 "cs.ATG" 
 			name = t.val; 
 			Expect(18);
 			if (StartOf(9)) {
 				FormalParameterList(
-#line  1213 "cs.ATG" 
+#line  1221 "cs.ATG" 
 out parameters);
 			}
 			Expect(19);
 			Expect(10);
 
-#line  1213 "cs.ATG" 
+#line  1221 "cs.ATG" 
 			MethodDeclaration md = new MethodDeclaration(name, mod, new TypeReference("void"), parameters, attributes);
 			md.StartLocation = startLocation;
 			md.EndLocation = t.EndLocation;
@@ -2216,27 +2216,27 @@
 		} else if (StartOf(18)) {
 			if (StartOf(8)) {
 				Type(
-#line  1219 "cs.ATG" 
+#line  1227 "cs.ATG" 
 out type);
 
-#line  1219 "cs.ATG" 
+#line  1227 "cs.ATG" 
 				if (startLocation.X == -1) startLocation = t.Location; 
 				if (la.kind == 1) {
 					lexer.NextToken();
 
-#line  1221 "cs.ATG" 
+#line  1229 "cs.ATG" 
 					name = t.val; Point qualIdentEndLocation = t.EndLocation; 
 					if (la.kind == 18) {
 						lexer.NextToken();
 						if (StartOf(9)) {
 							FormalParameterList(
-#line  1224 "cs.ATG" 
+#line  1232 "cs.ATG" 
 out parameters);
 						}
 						Expect(19);
 						Expect(10);
 
-#line  1224 "cs.ATG" 
+#line  1232 "cs.ATG" 
 						MethodDeclaration md = new MethodDeclaration(name, mod, type, parameters, attributes);
 						md.StartLocation = startLocation;
 						md.EndLocation = t.EndLocation;
@@ -2244,72 +2244,72 @@
 						
 					} else if (la.kind == 14) {
 
-#line  1230 "cs.ATG" 
+#line  1238 "cs.ATG" 
 						PropertyDeclaration pd = new PropertyDeclaration(name, type, mod, attributes); compilationUnit.AddChild(pd); 
 						lexer.NextToken();
 
-#line  1231 "cs.ATG" 
+#line  1239 "cs.ATG" 
 						Point bodyStart = t.Location;
 						InterfaceAccessors(
-#line  1231 "cs.ATG" 
+#line  1239 "cs.ATG" 
 out getBlock, out setBlock);
 						Expect(15);
 
-#line  1231 "cs.ATG" 
+#line  1239 "cs.ATG" 
 						pd.GetRegion = getBlock; pd.SetRegion = setBlock; pd.StartLocation = startLocation; pd.EndLocation = qualIdentEndLocation; pd.BodyStart = bodyStart; pd.BodyEnd = t.EndLocation; 
 					} else SynErr(151);
 				} else if (la.kind == 110) {
 					lexer.NextToken();
 					Expect(16);
 					FormalParameterList(
-#line  1234 "cs.ATG" 
+#line  1242 "cs.ATG" 
 out p);
 					Expect(17);
 
-#line  1234 "cs.ATG" 
+#line  1242 "cs.ATG" 
 					Point bracketEndLocation = t.EndLocation; 
 
-#line  1234 "cs.ATG" 
+#line  1242 "cs.ATG" 
 					IndexerDeclaration id = new IndexerDeclaration(type, p, mod, attributes); compilationUnit.AddChild(id); 
 					Expect(14);
 
-#line  1235 "cs.ATG" 
+#line  1243 "cs.ATG" 
 					Point bodyStart = t.Location;
 					InterfaceAccessors(
-#line  1235 "cs.ATG" 
+#line  1243 "cs.ATG" 
 out getBlock, out setBlock);
 					Expect(15);
 
-#line  1235 "cs.ATG" 
+#line  1243 "cs.ATG" 
 					id.GetRegion = getBlock; id.SetRegion = setBlock; id.StartLocation = startLocation;  id.EndLocation = bracketEndLocation; id.BodyStart = bodyStart; id.BodyEnd = t.EndLocation;
 				} else SynErr(152);
 			} else {
 				lexer.NextToken();
 
-#line  1238 "cs.ATG" 
+#line  1246 "cs.ATG" 
 				if (startLocation.X == -1) startLocation = t.Location; 
 				Type(
-#line  1238 "cs.ATG" 
+#line  1246 "cs.ATG" 
 out type);
 				Expect(1);
 
-#line  1238 "cs.ATG" 
+#line  1246 "cs.ATG" 
 				EventDeclaration ed = new EventDeclaration(type, t.val, mod, attributes);
 				compilationUnit.AddChild(ed);
 				
 				Expect(10);
 
-#line  1241 "cs.ATG" 
+#line  1249 "cs.ATG" 
 				ed.StartLocation = startLocation; ed.EndLocation = t.EndLocation; 
 			}
 		} else SynErr(153);
 	}
 
 	void EnumMemberDecl(
-#line  1246 "cs.ATG" 
+#line  1254 "cs.ATG" 
 out FieldDeclaration f) {
 
-#line  1248 "cs.ATG" 
+#line  1256 "cs.ATG" 
 		Expression expr = null;
 		ArrayList attributes = new ArrayList();
 		AttributeSection section = null;
@@ -2317,15 +2317,15 @@
 		
 		while (la.kind == 16) {
 			AttributeSection(
-#line  1254 "cs.ATG" 
+#line  1262 "cs.ATG" 
 out section);
 
-#line  1254 "cs.ATG" 
+#line  1262 "cs.ATG" 
 			attributes.Add(section); 
 		}
 		Expect(1);
 
-#line  1255 "cs.ATG" 
+#line  1263 "cs.ATG" 
 		f = new FieldDeclaration(attributes);
 		varDecl         = new VariableDeclaration(t.val);
 		f.Fields.Add(varDecl);
@@ -2334,10 +2334,10 @@
 		if (la.kind == 3) {
 			lexer.NextToken();
 			Expr(
-#line  1260 "cs.ATG" 
+#line  1268 "cs.ATG" 
 out expr);
 
-#line  1260 "cs.ATG" 
+#line  1268 "cs.ATG" 
 			varDecl.Initializer = expr; 
 		}
 	}
@@ -2458,12 +2458,38 @@
 		p = new ParameterDeclarationExpression(type, t.val, ParamModifiers.Params); 
 	}
 
+	void AccessorModifier(
+#line  971 "cs.ATG" 
+Modifiers m) {
+		if (la.kind == 83) {
+			lexer.NextToken();
+
+#line  973 "cs.ATG" 
+			m.Add(Modifier.Internal); 
+		} else if (la.kind == 97) {
+			lexer.NextToken();
+
+#line  974 "cs.ATG" 
+			m.Add(Modifier.Public); 
+		} else if (la.kind == 96) {
+			lexer.NextToken();
+
+#line  975 "cs.ATG" 
+			m.Add(Modifier.Protected); 
+		} else if (la.kind == 95) {
+			lexer.NextToken();
+
+#line  976 "cs.ATG" 
+			m.Add(Modifier.Private); 
+		} else SynErr(156);
+	}
+
 	void Block(
-#line  1364 "cs.ATG" 
+#line  1376 "cs.ATG" 
 out Statement stmt) {
 		Expect(14);
 
-#line  1366 "cs.ATG" 
+#line  1378 "cs.ATG" 
 		BlockStatement blockStmt = new BlockStatement();
 		blockStmt.StartLocation = t.Location;
 		compilationUnit.BlockStart(blockStmt);
@@ -2473,7 +2499,7 @@
 		}
 		Expect(15);
 
-#line  1371 "cs.ATG" 
+#line  1383 "cs.ATG" 
 		stmt = blockStmt;
 		blockStmt.EndLocation = t.EndLocation;
 		compilationUnit.BlockEnd();
@@ -2481,34 +2507,34 @@
 	}
 
 	void VariableDeclarator(
-#line  1357 "cs.ATG" 
+#line  1369 "cs.ATG" 
 ArrayList fieldDeclaration) {
 
-#line  1358 "cs.ATG" 
+#line  1370 "cs.ATG" 
 		Expression expr = null; 
 		Expect(1);
 
-#line  1360 "cs.ATG" 
+#line  1372 "cs.ATG" 
 		VariableDeclaration f = new VariableDeclaration(t.val); 
 		if (la.kind == 3) {
 			lexer.NextToken();
 			VariableInitializer(
-#line  1361 "cs.ATG" 
+#line  1373 "cs.ATG" 
 out expr);
 
-#line  1361 "cs.ATG" 
+#line  1373 "cs.ATG" 
 			f.Initializer = expr; 
 		}
 
-#line  1361 "cs.ATG" 
+#line  1373 "cs.ATG" 
 		fieldDeclaration.Add(f); 
 	}
 
 	void EventAccessorDecls(
-#line  1306 "cs.ATG" 
+#line  1318 "cs.ATG" 
 out EventAddRegion addBlock, out EventRemoveRegion removeBlock) {
 
-#line  1307 "cs.ATG" 
+#line  1319 "cs.ATG" 
 		AttributeSection section;
 		ArrayList attributes = new ArrayList();
 		Statement stmt;
@@ -2517,102 +2543,102 @@
 		
 		while (la.kind == 16) {
 			AttributeSection(
-#line  1314 "cs.ATG" 
+#line  1326 "cs.ATG" 
 out section);
 
-#line  1314 "cs.ATG" 
+#line  1326 "cs.ATG" 
 			attributes.Add(section); 
 		}
 		if (
-#line  1316 "cs.ATG" 
+#line  1328 "cs.ATG" 
 IdentIsAdd()) {
 
-#line  1316 "cs.ATG" 
+#line  1328 "cs.ATG" 
 			addBlock = new EventAddRegion(attributes); 
 			AddAccessorDecl(
-#line  1317 "cs.ATG" 
+#line  1329 "cs.ATG" 
 out stmt);
 
-#line  1317 "cs.ATG" 
+#line  1329 "cs.ATG" 
 			attributes = new ArrayList(); addBlock.Block = (BlockStatement)stmt; 
 			while (la.kind == 16) {
 				AttributeSection(
-#line  1318 "cs.ATG" 
+#line  1330 "cs.ATG" 
 out section);
 
-#line  1318 "cs.ATG" 
+#line  1330 "cs.ATG" 
 				attributes.Add(section); 
 			}
 			RemoveAccessorDecl(
-#line  1319 "cs.ATG" 
+#line  1331 "cs.ATG" 
 out stmt);
 
-#line  1319 "cs.ATG" 
+#line  1331 "cs.ATG" 
 			removeBlock = new EventRemoveRegion(attributes); removeBlock.Block = (BlockStatement)stmt; 
 		} else if (
-#line  1320 "cs.ATG" 
+#line  1332 "cs.ATG" 
 IdentIsRemove()) {
 			RemoveAccessorDecl(
-#line  1321 "cs.ATG" 
+#line  1333 "cs.ATG" 
 out stmt);
 
-#line  1321 "cs.ATG" 
+#line  1333 "cs.ATG" 
 			removeBlock = new EventRemoveRegion(attributes); removeBlock.Block = (BlockStatement)stmt; attributes = new ArrayList(); 
 			while (la.kind == 16) {
 				AttributeSection(
-#line  1322 "cs.ATG" 
+#line  1334 "cs.ATG" 
 out section);
 
-#line  1322 "cs.ATG" 
+#line  1334 "cs.ATG" 
 				attributes.Add(section); 
 			}
 			AddAccessorDecl(
-#line  1323 "cs.ATG" 
+#line  1335 "cs.ATG" 
 out stmt);
 
-#line  1323 "cs.ATG" 
+#line  1335 "cs.ATG" 
 			addBlock = new EventAddRegion(attributes); addBlock.Block = (BlockStatement)stmt; 
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 
-#line  1324 "cs.ATG" 
+#line  1336 "cs.ATG" 
 			Error("add or remove accessor declaration expected"); 
-		} else SynErr(156);
+		} else SynErr(157);
 	}
 
 	void ConstructorInitializer(
-#line  1393 "cs.ATG" 
+#line  1405 "cs.ATG" 
 out ConstructorInitializer ci) {
 
-#line  1394 "cs.ATG" 
+#line  1406 "cs.ATG" 
 		Expression expr; ci = new ConstructorInitializer(); 
 		Expect(9);
 		if (la.kind == 50) {
 			lexer.NextToken();
 
-#line  1398 "cs.ATG" 
+#line  1410 "cs.ATG" 
 			ci.ConstructorInitializerType = ConstructorInitializerType.Base; 
 		} else if (la.kind == 110) {
 			lexer.NextToken();
 
-#line  1399 "cs.ATG" 
+#line  1411 "cs.ATG" 
 			ci.ConstructorInitializerType = ConstructorInitializerType.This; 
-		} else SynErr(157);
+		} else SynErr(158);
 		Expect(18);
 		if (StartOf(21)) {
 			Argument(
-#line  1402 "cs.ATG" 
+#line  1414 "cs.ATG" 
 out expr);
 
-#line  1402 "cs.ATG" 
+#line  1414 "cs.ATG" 
 			ci.Arguments.Add(expr); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Argument(
-#line  1402 "cs.ATG" 
+#line  1414 "cs.ATG" 
 out expr);
 
-#line  1402 "cs.ATG" 
+#line  1414 "cs.ATG" 
 				ci.Arguments.Add(expr); 
 			}
 		}
@@ -2620,7 +2646,7 @@
 	}
 
 	void OverloadableOperator(
-#line  1414 "cs.ATG" 
+#line  1426 "cs.ATG" 
 out Token op) {
 		switch (la.kind) {
 		case 4: {
@@ -2711,343 +2737,359 @@
 			lexer.NextToken();
 			break;
 		}
-		default: SynErr(158); break;
+		default: SynErr(159); break;
 		}
 
-#line  1423 "cs.ATG" 
+#line  1435 "cs.ATG" 
 		op = t; 
 	}
 
 	void AccessorDecls(
-#line  1264 "cs.ATG" 
+#line  1272 "cs.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-#line  1266 "cs.ATG" 
+#line  1274 "cs.ATG" 
 		ArrayList attributes = new ArrayList(); 
+		Modifiers m = new Modifiers (this);
 		AttributeSection section;
 		getBlock = null;
 		setBlock = null; 
 		
 		while (la.kind == 16) {
 			AttributeSection(
-#line  1272 "cs.ATG" 
+#line  1281 "cs.ATG" 
 out section);
 
-#line  1272 "cs.ATG" 
+#line  1281 "cs.ATG" 
 			attributes.Add(section); 
 		}
+		while (StartOf(22)) {
+			AccessorModifier(
+#line  1282 "cs.ATG" 
+m);
+		}
 		if (
-#line  1274 "cs.ATG" 
+#line  1284 "cs.ATG" 
 IdentIsGet()) {
 			GetAccessorDecl(
-#line  1275 "cs.ATG" 
-out getBlock, attributes);
-			if (la.kind == 1 || la.kind == 16) {
+#line  1285 "cs.ATG" 
+out getBlock, attributes, m.Modifier);
+			if (StartOf(23)) {
 
-#line  1276 "cs.ATG" 
-				attributes = new ArrayList(); 
+#line  1286 "cs.ATG" 
+				attributes = new ArrayList(); m = new Modifiers (this); 
 				while (la.kind == 16) {
 					AttributeSection(
-#line  1277 "cs.ATG" 
+#line  1287 "cs.ATG" 
 out section);
 
-#line  1277 "cs.ATG" 
+#line  1287 "cs.ATG" 
 					attributes.Add(section); 
 				}
+				while (StartOf(22)) {
+					AccessorModifier(
+#line  1288 "cs.ATG" 
+m);
+				}
 				SetAccessorDecl(
-#line  1278 "cs.ATG" 
-out setBlock, attributes);
+#line  1289 "cs.ATG" 
+out setBlock, attributes, m.Modifier);
 			}
 		} else if (
-#line  1280 "cs.ATG" 
+#line  1291 "cs.ATG" 
 IdentIsSet()) {
 			SetAccessorDecl(
-#line  1281 "cs.ATG" 
-out setBlock, attributes);
-			if (la.kind == 1 || la.kind == 16) {
+#line  1292 "cs.ATG" 
+out setBlock, attributes, m.Modifier);
+			if (StartOf(23)) {
 
-#line  1282 "cs.ATG" 
-				attributes = new ArrayList(); 
+#line  1293 "cs.ATG" 
+				attributes = new ArrayList(); m = new Modifiers (this); 
 				while (la.kind == 16) {
 					AttributeSection(
-#line  1283 "cs.ATG" 
+#line  1294 "cs.ATG" 
 out section);
 
-#line  1283 "cs.ATG" 
+#line  1294 "cs.ATG" 
 					attributes.Add(section); 
 				}
+				while (StartOf(22)) {
+					AccessorModifier(
+#line  1295 "cs.ATG" 
+m);
+				}
 				GetAccessorDecl(
-#line  1284 "cs.ATG" 
-out getBlock, attributes);
+#line  1296 "cs.ATG" 
+out getBlock, attributes, m.Modifier);
 			}
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 
-#line  1286 "cs.ATG" 
+#line  1298 "cs.ATG" 
 			Error("get or set accessor declaration expected"); 
-		} else SynErr(159);
+		} else SynErr(160);
 	}
 
 	void InterfaceAccessors(
-#line  1328 "cs.ATG" 
+#line  1340 "cs.ATG" 
 out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
 
-#line  1330 "cs.ATG" 
+#line  1342 "cs.ATG" 
 		AttributeSection section;
 		ArrayList attributes = new ArrayList();
 		getBlock = null; setBlock = null;
 		
 		while (la.kind == 16) {
 			AttributeSection(
-#line  1335 "cs.ATG" 
+#line  1347 "cs.ATG" 
 out section);
 
-#line  1335 "cs.ATG" 
+#line  1347 "cs.ATG" 
 			attributes.Add(section); 
 		}
 		if (
-#line  1337 "cs.ATG" 
+#line  1349 "cs.ATG" 
 IdentIsGet()) {
 			Expect(1);
 
-#line  1337 "cs.ATG" 
+#line  1349 "cs.ATG" 
 			getBlock = new PropertyGetRegion(null, attributes); 
 		} else if (
-#line  1338 "cs.ATG" 
+#line  1350 "cs.ATG" 
 IdentIsSet()) {
 			Expect(1);
 
-#line  1338 "cs.ATG" 
+#line  1350 "cs.ATG" 
 			setBlock = new PropertySetRegion(null, attributes); 
 		} else if (la.kind == 1) {
 			lexer.NextToken();
 
-#line  1339 "cs.ATG" 
+#line  1351 "cs.ATG" 
 			Error("set or get expected"); 
-		} else SynErr(160);
+		} else SynErr(161);
 		Expect(10);
 
-#line  1341 "cs.ATG" 
+#line  1353 "cs.ATG" 
 		attributes = new ArrayList(); 
 		if (la.kind == 1 || la.kind == 16) {
 			while (la.kind == 16) {
 				AttributeSection(
-#line  1343 "cs.ATG" 
+#line  1355 "cs.ATG" 
 out section);
 
-#line  1343 "cs.ATG" 
+#line  1355 "cs.ATG" 
 				attributes.Add(section); 
 			}
 			if (
-#line  1345 "cs.ATG" 
+#line  1357 "cs.ATG" 
 IdentIsGet()) {
 				Expect(1);
 
-#line  1345 "cs.ATG" 
+#line  1357 "cs.ATG" 
 				if (getBlock != null) Error("get already declared");
 				else getBlock = new PropertyGetRegion(null, attributes);
 				
 			} else if (
-#line  1348 "cs.ATG" 
+#line  1360 "cs.ATG" 
 IdentIsSet()) {
 				Expect(1);
 
-#line  1348 "cs.ATG" 
+#line  1360 "cs.ATG" 
 				if (setBlock != null) Error("set already declared");
 				else setBlock = new PropertySetRegion(null, attributes);
 				
 			} else if (la.kind == 1) {
 				lexer.NextToken();
 
-#line  1351 "cs.ATG" 
+#line  1363 "cs.ATG" 
 				Error("set or get expected"); 
-			} else SynErr(161);
+			} else SynErr(162);
 			Expect(10);
 		}
 	}
 
 	void GetAccessorDecl(
-#line  1290 "cs.ATG" 
-out PropertyGetRegion getBlock, ArrayList attributes) {
+#line  1302 "cs.ATG" 
+out PropertyGetRegion getBlock, ArrayList attributes, Modifier m) {
 
-#line  1291 "cs.ATG" 
+#line  1303 "cs.ATG" 
 		Statement stmt = null; 
 		Expect(1);
 
-#line  1294 "cs.ATG" 
+#line  1306 "cs.ATG" 
 		if (t.val != "get") Error("get expected"); 
 		if (la.kind == 14) {
 			Block(
-#line  1295 "cs.ATG" 
+#line  1307 "cs.ATG" 
 out stmt);
 		} else if (la.kind == 10) {
 			lexer.NextToken();
-		} else SynErr(162);
+		} else SynErr(163);
 
-#line  1295 "cs.ATG" 
-		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); 
+#line  1307 "cs.ATG" 
+		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes, m); 
 	}
 
 	void SetAccessorDecl(
-#line  1298 "cs.ATG" 
-out PropertySetRegion setBlock, ArrayList attributes) {
+#line  1310 "cs.ATG" 
+out PropertySetRegion setBlock, ArrayList attributes, Modifier m) {
 
-#line  1299 "cs.ATG" 
+#line  1311 "cs.ATG" 
 		Statement stmt = null; 
 		Expect(1);
 
-#line  1302 "cs.ATG" 
+#line  1314 "cs.ATG" 
 		if (t.val != "set") Error("set expected"); 
 		if (la.kind == 14) {
 			Block(
-#line  1303 "cs.ATG" 
+#line  1315 "cs.ATG" 
 out stmt);
 		} else if (la.kind == 10) {
 			lexer.NextToken();
-		} else SynErr(163);
+		} else SynErr(164);
 
-#line  1303 "cs.ATG" 
-		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes); 
+#line  1315 "cs.ATG" 
+		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes, m); 
 	}
 
 	void AddAccessorDecl(
-#line  1377 "cs.ATG" 
+#line  1389 "cs.ATG" 
 out Statement stmt) {
 
-#line  1378 "cs.ATG" 
+#line  1390 "cs.ATG" 
 		stmt = null;
 		Expect(1);
 
-#line  1381 "cs.ATG" 
+#line  1393 "cs.ATG" 
 		if (t.val != "add") Error("add expected"); 
 		Block(
-#line  1382 "cs.ATG" 
+#line  1394 "cs.ATG" 
 out stmt);
 	}
 
 	void RemoveAccessorDecl(
-#line  1385 "cs.ATG" 
+#line  1397 "cs.ATG" 
 out Statement stmt) {
 
-#line  1386 "cs.ATG" 
+#line  1398 "cs.ATG" 
 		stmt = null;
 		Expect(1);
 
-#line  1389 "cs.ATG" 
+#line  1401 "cs.ATG" 
 		if (t.val != "remove") Error("remove expected"); 
 		Block(
-#line  1390 "cs.ATG" 
+#line  1402 "cs.ATG" 
 out stmt);
 	}
 
 	void VariableInitializer(
-#line  1406 "cs.ATG" 
+#line  1418 "cs.ATG" 
 out Expression initializerExpression) {
 
-#line  1407 "cs.ATG" 
+#line  1419 "cs.ATG" 
 		TypeReference type = null; Expression expr = null; initializerExpression = null; 
 		if (StartOf(4)) {
 			Expr(
-#line  1409 "cs.ATG" 
+#line  1421 "cs.ATG" 
 out initializerExpression);
 		} else if (la.kind == 14) {
 			ArrayInitializer(
-#line  1410 "cs.ATG" 
+#line  1422 "cs.ATG" 
 out initializerExpression);
 		} else if (la.kind == 105) {
 			lexer.NextToken();
 			Type(
-#line  1411 "cs.ATG" 
+#line  1423 "cs.ATG" 
 out type);
 			Expect(16);
 			Expr(
-#line  1411 "cs.ATG" 
+#line  1423 "cs.ATG" 
 out expr);
 			Expect(17);
 
-#line  1411 "cs.ATG" 
+#line  1423 "cs.ATG" 
 			initializerExpression = new StackAllocExpression(type, expr); 
-		} else SynErr(164);
+		} else SynErr(165);
 	}
 
 	void Statement() {
 
-#line  1494 "cs.ATG" 
+#line  1506 "cs.ATG" 
 		TypeReference type;
 		Expression expr;
 		Statement stmt;
 		
 		if (
-#line  1500 "cs.ATG" 
+#line  1512 "cs.ATG" 
 IsLabel()) {
 			Expect(1);
 
-#line  1500 "cs.ATG" 
+#line  1512 "cs.ATG" 
 			compilationUnit.AddChild(new LabelStatement(t.val)); 
 			Expect(9);
 			Statement();
 		} else if (la.kind == 59) {
 			lexer.NextToken();
 			Type(
-#line  1503 "cs.ATG" 
+#line  1515 "cs.ATG" 
 out type);
 
-#line  1503 "cs.ATG" 
+#line  1515 "cs.ATG" 
 			LocalVariableDeclaration var = new LocalVariableDeclaration(type, Modifier.Const); string ident = null; var.StartLocation = t.Location; 
 			Expect(1);
 
-#line  1504 "cs.ATG" 
+#line  1516 "cs.ATG" 
 			ident = t.val; 
 			Expect(3);
 			Expr(
-#line  1505 "cs.ATG" 
+#line  1517 "cs.ATG" 
 out expr);
 
-#line  1505 "cs.ATG" 
+#line  1517 "cs.ATG" 
 			var.Variables.Add(new VariableDeclaration(ident, expr)); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  1506 "cs.ATG" 
+#line  1518 "cs.ATG" 
 				ident = t.val; 
 				Expect(3);
 				Expr(
-#line  1506 "cs.ATG" 
+#line  1518 "cs.ATG" 
 out expr);
 
-#line  1506 "cs.ATG" 
+#line  1518 "cs.ATG" 
 				var.Variables.Add(new VariableDeclaration(ident, expr)); 
 			}
 			Expect(10);
 
-#line  1507 "cs.ATG" 
+#line  1519 "cs.ATG" 
 			compilationUnit.AddChild(var); 
 		} else if (
-#line  1509 "cs.ATG" 
+#line  1521 "cs.ATG" 
 IsLocalVarDecl()) {
 			LocalVariableDecl(
-#line  1509 "cs.ATG" 
+#line  1521 "cs.ATG" 
 out stmt);
 			Expect(10);
 
-#line  1509 "cs.ATG" 
+#line  1521 "cs.ATG" 
 			compilationUnit.AddChild(stmt); 
-		} else if (StartOf(22)) {
+		} else if (StartOf(24)) {
 			EmbeddedStatement(
-#line  1510 "cs.ATG" 
+#line  1522 "cs.ATG" 
 out stmt);
 
-#line  1510 "cs.ATG" 
+#line  1522 "cs.ATG" 
 			compilationUnit.AddChild(stmt); 
-		} else SynErr(165);
+		} else SynErr(166);
 	}
 
 	void Argument(
-#line  1426 "cs.ATG" 
+#line  1438 "cs.ATG" 
 out Expression argumentexpr) {
 
-#line  1428 "cs.ATG" 
+#line  1440 "cs.ATG" 
 		Expression expr;
 		FieldDirection fd = FieldDirection.None;
 		
@@ -3055,48 +3097,48 @@
 			if (la.kind == 99) {
 				lexer.NextToken();
 
-#line  1433 "cs.ATG" 
+#line  1445 "cs.ATG" 
 				fd = FieldDirection.Ref; 
 			} else {
 				lexer.NextToken();
 
-#line  1434 "cs.ATG" 
+#line  1446 "cs.ATG" 
 				fd = FieldDirection.Out; 
 			}
 		}
 		Expr(
-#line  1436 "cs.ATG" 
+#line  1448 "cs.ATG" 
 out expr);
 
-#line  1436 "cs.ATG" 
+#line  1448 "cs.ATG" 
 		argumentexpr = fd != FieldDirection.None ? argumentexpr = new DirectionExpression(fd, expr) : expr; 
 	}
 
 	void ArrayInitializer(
-#line  1455 "cs.ATG" 
+#line  1467 "cs.ATG" 
 out Expression outExpr) {
 
-#line  1457 "cs.ATG" 
+#line  1469 "cs.ATG" 
 		Expression expr = null;
 		ArrayInitializerExpression initializer = new ArrayInitializerExpression();
 		
 		Expect(14);
-		if (StartOf(23)) {
+		if (StartOf(25)) {
 			VariableInitializer(
-#line  1462 "cs.ATG" 
+#line  1474 "cs.ATG" 
 out expr);
 
-#line  1462 "cs.ATG" 
+#line  1474 "cs.ATG" 
 			initializer.CreateExpressions.Add(expr); 
 			while (
-#line  1462 "cs.ATG" 
+#line  1474 "cs.ATG" 
 NotFinalComma()) {
 				Expect(12);
 				VariableInitializer(
-#line  1462 "cs.ATG" 
+#line  1474 "cs.ATG" 
 out expr);
 
-#line  1462 "cs.ATG" 
+#line  1474 "cs.ATG" 
 				initializer.CreateExpressions.Add(expr); 
 			}
 			if (la.kind == 12) {
@@ -3105,176 +3147,176 @@
 		}
 		Expect(15);
 
-#line  1463 "cs.ATG" 
+#line  1475 "cs.ATG" 
 		outExpr = initializer; 
 	}
 
 	void AssignmentOperator(
-#line  1439 "cs.ATG" 
+#line  1451 "cs.ATG" 
 out AssignmentOperatorType op) {
 
-#line  1440 "cs.ATG" 
+#line  1452 "cs.ATG" 
 		op = AssignmentOperatorType.None; 
 		switch (la.kind) {
 		case 3: {
 			lexer.NextToken();
 
-#line  1442 "cs.ATG" 
+#line  1454 "cs.ATG" 
 			op = AssignmentOperatorType.Assign; 
 			break;
 		}
 		case 37: {
 			lexer.NextToken();
 
-#line  1443 "cs.ATG" 
+#line  1455 "cs.ATG" 
 			op = AssignmentOperatorType.Add; 
 			break;
 		}
 		case 38: {
 			lexer.NextToken();
 
-#line  1444 "cs.ATG" 
+#line  1456 "cs.ATG" 
 			op = AssignmentOperatorType.Subtract; 
 			break;
 		}
 		case 39: {
 			lexer.NextToken();
 
-#line  1445 "cs.ATG" 
+#line  1457 "cs.ATG" 
 			op = AssignmentOperatorType.Multiply; 
 			break;
 		}
 		case 40: {
 			lexer.NextToken();
 
-#line  1446 "cs.ATG" 
+#line  1458 "cs.ATG" 
 			op = AssignmentOperatorType.Divide; 
 			break;
 		}
 		case 41: {
 			lexer.NextToken();
 
-#line  1447 "cs.ATG" 
+#line  1459 "cs.ATG" 
 			op = AssignmentOperatorType.Modulus; 
 			break;
 		}
 		case 42: {
 			lexer.NextToken();
 
-#line  1448 "cs.ATG" 
+#line  1460 "cs.ATG" 
 			op = AssignmentOperatorType.BitwiseAnd; 
 			break;
 		}
 		case 43: {
 			lexer.NextToken();
 
-#line  1449 "cs.ATG" 
+#line  1461 "cs.ATG" 
 			op = AssignmentOperatorType.BitwiseOr; 
 			break;
 		}
 		case 44: {
 			lexer.NextToken();
 
-#line  1450 "cs.ATG" 
+#line  1462 "cs.ATG" 
 			op = AssignmentOperatorType.ExclusiveOr; 
 			break;
 		}
 		case 45: {
 			lexer.NextToken();
 
-#line  1451 "cs.ATG" 
+#line  1463 "cs.ATG" 
 			op = AssignmentOperatorType.ShiftLeft; 
 			break;
 		}
 		case 46: {
 			lexer.NextToken();
 
-#line  1452 "cs.ATG" 
+#line  1464 "cs.ATG" 
 			op = AssignmentOperatorType.ShiftRight; 
 			break;
 		}
-		default: SynErr(166); break;
+		default: SynErr(167); break;
 		}
 	}
 
 	void LocalVariableDecl(
-#line  1466 "cs.ATG" 
+#line  1478 "cs.ATG" 
 out Statement stmt) {
 
-#line  1468 "cs.ATG" 
+#line  1480 "cs.ATG" 
 		TypeReference type;
 		VariableDeclaration      var = null;
 		LocalVariableDeclaration localVariableDeclaration; 
 		
 		Type(
-#line  1473 "cs.ATG" 
+#line  1485 "cs.ATG" 
 out type);
 
-#line  1473 "cs.ATG" 
+#line  1485 "cs.ATG" 
 		localVariableDeclaration = new LocalVariableDeclaration(type); localVariableDeclaration.StartLocation = t.Location; 
 		LocalVariableDeclarator(
-#line  1474 "cs.ATG" 
+#line  1486 "cs.ATG" 
 out var);
 
-#line  1474 "cs.ATG" 
+#line  1486 "cs.ATG" 
 		localVariableDeclaration.Variables.Add(var); 
 		while (la.kind == 12) {
 			lexer.NextToken();
 			LocalVariableDeclarator(
-#line  1475 "cs.ATG" 
+#line  1487 "cs.ATG" 
 out var);
 
-#line  1475 "cs.ATG" 
+#line  1487 "cs.ATG" 
 			localVariableDeclaration.Variables.Add(var); 
 		}
 
-#line  1476 "cs.ATG" 
+#line  1488 "cs.ATG" 
 		stmt = localVariableDeclaration; 
 	}
 
 	void LocalVariableDeclarator(
-#line  1479 "cs.ATG" 
+#line  1491 "cs.ATG" 
 out VariableDeclaration var) {
 
-#line  1480 "cs.ATG" 
+#line  1492 "cs.ATG" 
 		Expression expr = null; 
 		Expect(1);
 
-#line  1482 "cs.ATG" 
+#line  1494 "cs.ATG" 
 		var = new VariableDeclaration(t.val); 
 		if (la.kind == 3) {
 			lexer.NextToken();
 			LocalVariableInitializer(
-#line  1482 "cs.ATG" 
+#line  1494 "cs.ATG" 
 out expr);
 
-#line  1482 "cs.ATG" 
+#line  1494 "cs.ATG" 
 			var.Initializer = expr; 
 		}
 	}
 
 	void LocalVariableInitializer(
-#line  1485 "cs.ATG" 
+#line  1497 "cs.ATG" 
 out Expression expr) {
 
-#line  1486 "cs.ATG" 
+#line  1498 "cs.ATG" 
 		expr = null; 
 		if (StartOf(4)) {
 			Expr(
-#line  1488 "cs.ATG" 
+#line  1500 "cs.ATG" 
 out expr);
 		} else if (la.kind == 14) {
 			ArrayInitializer(
-#line  1489 "cs.ATG" 
+#line  1501 "cs.ATG" 
 out expr);
-		} else SynErr(167);
+		} else SynErr(168);
 	}
 
 	void EmbeddedStatement(
-#line  1516 "cs.ATG" 
+#line  1528 "cs.ATG" 
 out Statement statement) {
 
-#line  1518 "cs.ATG" 
+#line  1530 "cs.ATG" 
 		TypeReference type = null;
 		Expression expr = null;
 		Statement embeddedStatement = null;
@@ -3282,161 +3324,161 @@
 		
 		if (la.kind == 14) {
 			Block(
-#line  1524 "cs.ATG" 
+#line  1536 "cs.ATG" 
 out statement);
 		} else if (la.kind == 10) {
 			lexer.NextToken();
 
-#line  1526 "cs.ATG" 
+#line  1538 "cs.ATG" 
 			statement = new EmptyStatement(); 
 		} else if (
-#line  1528 "cs.ATG" 
+#line  1540 "cs.ATG" 
 UnCheckedAndLBrace()) {
 
-#line  1528 "cs.ATG" 
+#line  1540 "cs.ATG" 
 			Statement block; bool isChecked = true; 
 			if (la.kind == 57) {
 				lexer.NextToken();
 			} else if (la.kind == 117) {
 				lexer.NextToken();
 
-#line  1529 "cs.ATG" 
+#line  1541 "cs.ATG" 
 				isChecked = false;
-			} else SynErr(168);
+			} else SynErr(169);
 			Block(
-#line  1530 "cs.ATG" 
+#line  1542 "cs.ATG" 
 out block);
 
-#line  1530 "cs.ATG" 
+#line  1542 "cs.ATG" 
 			statement = isChecked ? (Statement)new CheckedStatement(block) : (Statement)new UncheckedStatement(block); 
 		} else if (StartOf(4)) {
 			StatementExpr(
-#line  1532 "cs.ATG" 
+#line  1544 "cs.ATG" 
 out statement);
 			Expect(10);
 		} else if (la.kind == 78) {
 			lexer.NextToken();
 
-#line  1534 "cs.ATG" 
+#line  1546 "cs.ATG" 
 			Statement elseStatement = null; 
 			Expect(18);
 			Expr(
-#line  1535 "cs.ATG" 
+#line  1547 "cs.ATG" 
 out expr);
 			Expect(19);
 			EmbeddedStatement(
-#line  1536 "cs.ATG" 
+#line  1548 "cs.ATG" 
 out embeddedStatement);
 			if (la.kind == 66) {
 				lexer.NextToken();
 				EmbeddedStatement(
-#line  1537 "cs.ATG" 
+#line  1549 "cs.ATG" 
 out elseStatement);
 			}
 
-#line  1538 "cs.ATG" 
+#line  1550 "cs.ATG" 
 			statement = elseStatement != null ? (Statement)new IfElseStatement(expr, embeddedStatement, elseStatement) :  (Statement)new IfStatement(expr, embeddedStatement); 
 		} else if (la.kind == 109) {
 			lexer.NextToken();
 
-#line  1539 "cs.ATG" 
+#line  1551 "cs.ATG" 
 			ArrayList switchSections = new ArrayList(); 
 			Expect(18);
 			Expr(
-#line  1540 "cs.ATG" 
+#line  1552 "cs.ATG" 
 out expr);
 			Expect(19);
 			Expect(14);
 			while (la.kind == 54 || la.kind == 62) {
 				SwitchSection(
-#line  1541 "cs.ATG" 
+#line  1553 "cs.ATG" 
 out statement);
 
-#line  1541 "cs.ATG" 
+#line  1553 "cs.ATG" 
 				switchSections.Add(statement); 
 			}
 			Expect(15);
 
-#line  1542 "cs.ATG" 
+#line  1554 "cs.ATG" 
 			statement = new SwitchStatement(expr, switchSections); 
 		} else if (la.kind == 124) {
 			lexer.NextToken();
 			Expect(18);
 			Expr(
-#line  1544 "cs.ATG" 
+#line  1556 "cs.ATG" 
 out expr);
 			Expect(19);
 			EmbeddedStatement(
-#line  1545 "cs.ATG" 
+#line  1557 "cs.ATG" 
 out embeddedStatement);
 
-#line  1545 "cs.ATG" 
+#line  1557 "cs.ATG" 
 			statement = new WhileStatement(expr, embeddedStatement); 
 		} else if (la.kind == 64) {
 			lexer.NextToken();
 			EmbeddedStatement(
-#line  1546 "cs.ATG" 
+#line  1558 "cs.ATG" 
 out embeddedStatement);
 			Expect(124);
 			Expect(18);
 			Expr(
-#line  1547 "cs.ATG" 
+#line  1559 "cs.ATG" 
 out expr);
 			Expect(19);
 			Expect(10);
 
-#line  1547 "cs.ATG" 
+#line  1559 "cs.ATG" 
 			statement = new DoWhileStatement(expr, embeddedStatement); 
 		} else if (la.kind == 75) {
 			lexer.NextToken();
 
-#line  1548 "cs.ATG" 
+#line  1560 "cs.ATG" 
 			ArrayList initializer = null, iterator = null; 
 			Expect(18);
 			if (StartOf(4)) {
 				ForInitializer(
-#line  1549 "cs.ATG" 
+#line  1561 "cs.ATG" 
 out initializer);
 			}
 			Expect(10);
 			if (StartOf(4)) {
 				Expr(
-#line  1550 "cs.ATG" 
+#line  1562 "cs.ATG" 
 out expr);
 			}
 			Expect(10);
 			if (StartOf(4)) {
 				ForIterator(
-#line  1551 "cs.ATG" 
+#line  1563 "cs.ATG" 
 out iterator);
 			}
 			Expect(19);
 			EmbeddedStatement(
-#line  1552 "cs.ATG" 
+#line  1564 "cs.ATG" 
 out embeddedStatement);
 
-#line  1552 "cs.ATG" 
+#line  1564 "cs.ATG" 
 			statement = new ForStatement(initializer, expr, iterator, embeddedStatement); 
 		} else if (la.kind == 76) {
 			lexer.NextToken();
 			Expect(18);
 			Type(
-#line  1553 "cs.ATG" 
+#line  1565 "cs.ATG" 
 out type);
 			Expect(1);
 
-#line  1553 "cs.ATG" 
+#line  1565 "cs.ATG" 
 			string varName = t.val; 
 			Expect(80);
 			Expr(
-#line  1554 "cs.ATG" 
+#line  1566 "cs.ATG" 
 out expr);
 			Expect(19);
 			EmbeddedStatement(
-#line  1555 "cs.ATG" 
+#line  1567 "cs.ATG" 
 out embeddedStatement);
 
-#line  1555 "cs.ATG" 
+#line  1567 "cs.ATG" 
 			statement = new ForeachStatement(type, varName , expr, embeddedStatement); 
 			statement.EndLocation = t.EndLocation;
 			
@@ -3444,519 +3486,519 @@
 			lexer.NextToken();
 			Expect(10);
 
-#line  1559 "cs.ATG" 
+#line  1571 "cs.ATG" 
 			statement = new BreakStatement(); 
 		} else if (la.kind == 60) {
 			lexer.NextToken();
 			Expect(10);
 
-#line  1560 "cs.ATG" 
+#line  1572 "cs.ATG" 
 			statement = new ContinueStatement(); 
 		} else if (la.kind == 77) {
 			GotoStatement(
-#line  1561 "cs.ATG" 
+#line  1573 "cs.ATG" 
 out statement);
 		} else if (la.kind == 100) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				Expr(
-#line  1562 "cs.ATG" 
+#line  1574 "cs.ATG" 
 out expr);
 			}
 			Expect(10);
 
-#line  1562 "cs.ATG" 
+#line  1574 "cs.ATG" 
 			statement = new ReturnStatement(expr); 
 		} else if (la.kind == 111) {
 			lexer.NextToken();
 			if (StartOf(4)) {
 				Expr(
-#line  1563 "cs.ATG" 
+#line  1575 "cs.ATG" 
 out expr);
 			}
 			Expect(10);
 
-#line  1563 "cs.ATG" 
+#line  1575 "cs.ATG" 
 			statement = new ThrowStatement(expr); 
 		} else if (la.kind == 113) {
 			TryStatement(
-#line  1565 "cs.ATG" 
+#line  1577 "cs.ATG" 
 out statement);
 		} else if (la.kind == 85) {
 			lexer.NextToken();
 			Expect(18);
 			Expr(
-#line  1567 "cs.ATG" 
+#line  1579 "cs.ATG" 
 out expr);
 			Expect(19);
 			EmbeddedStatement(
-#line  1568 "cs.ATG" 
+#line  1580 "cs.ATG" 
 out embeddedStatement);
 
-#line  1568 "cs.ATG" 
+#line  1580 "cs.ATG" 
 			statement = new LockStatement(expr, embeddedStatement); 
 		} else if (la.kind == 120) {
 
-#line  1570 "cs.ATG" 
+#line  1582 "cs.ATG" 
 			Statement resourceAcquisitionStmt = null; 
 			lexer.NextToken();
 			Expect(18);
 			ResourceAcquisition(
-#line  1572 "cs.ATG" 
+#line  1584 "cs.ATG" 
 out resourceAcquisitionStmt);
 			Expect(19);
 			EmbeddedStatement(
-#line  1573 "cs.ATG" 
+#line  1585 "cs.ATG" 
 out embeddedStatement);
 
-#line  1573 "cs.ATG" 
+#line  1585 "cs.ATG" 
 			statement = new UsingStatement(resourceAcquisitionStmt, embeddedStatement); 
 		} else if (la.kind == 118) {
 			lexer.NextToken();
 			Block(
-#line  1575 "cs.ATG" 
+#line  1587 "cs.ATG" 
 out embeddedStatement);
 
-#line  1575 "cs.ATG" 
+#line  1587 "cs.ATG" 
 			statement = new UnsafeStatement(embeddedStatement); 
 		} else if (la.kind == 73) {
 			lexer.NextToken();
 			Expect(18);
 			Type(
-#line  1578 "cs.ATG" 
+#line  1590 "cs.ATG" 
 out type);
 
-#line  1578 "cs.ATG" 
+#line  1590 "cs.ATG" 
 			if (type.PointerNestingLevel == 0) Error("can only fix pointer types");
 			FixedStatement fxStmt = new FixedStatement(type);
 			string identifier = null;
 			
 			Expect(1);
 
-#line  1582 "cs.ATG" 
+#line  1594 "cs.ATG" 
 			identifier = t.val; 
 			Expect(3);
 			Expr(
-#line  1583 "cs.ATG" 
+#line  1595 "cs.ATG" 
 out expr);
 
-#line  1583 "cs.ATG" 
+#line  1595 "cs.ATG" 
 			fxStmt.PointerDeclarators.Add(new VariableDeclaration(identifier, expr)); 
 			while (la.kind == 12) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  1585 "cs.ATG" 
+#line  1597 "cs.ATG" 
 				identifier = t.val; 
 				Expect(3);
 				Expr(
-#line  1586 "cs.ATG" 
+#line  1598 "cs.ATG" 
 out expr);
 
-#line  1586 "cs.ATG" 
+#line  1598 "cs.ATG" 
 				fxStmt.PointerDeclarators.Add(new VariableDeclaration(identifier, expr)); 
 			}
 			Expect(19);
 			EmbeddedStatement(
-#line  1588 "cs.ATG" 
+#line  1600 "cs.ATG" 
 out embeddedStatement);
 
-#line  1588 "cs.ATG" 
+#line  1600 "cs.ATG" 
 			fxStmt.EmbeddedStatement = embeddedStatement; statement = fxStmt;
-		} else SynErr(169);
+		} else SynErr(170);
 	}
 
 	void StatementExpr(
-#line  1696 "cs.ATG" 
+#line  1708 "cs.ATG" 
 out Statement stmt) {
 
-#line  1701 "cs.ATG" 
+#line  1713 "cs.ATG" 
 		bool mustBeAssignment = la.kind == Tokens.Plus  || la.kind == Tokens.Minus ||
 		                       la.kind == Tokens.Not   || la.kind == Tokens.BitwiseComplement ||
 		                       la.kind == Tokens.Times || la.kind == Tokens.BitwiseAnd   || IsTypeCast();
 		Expression expr = null;
 		
 		UnaryExpr(
-#line  1707 "cs.ATG" 
+#line  1719 "cs.ATG" 
 out expr);
 		if (StartOf(6)) {
 
-#line  1710 "cs.ATG" 
+#line  1722 "cs.ATG" 
 			AssignmentOperatorType op; Expression val; 
 			AssignmentOperator(
-#line  1710 "cs.ATG" 
+#line  1722 "cs.ATG" 
 out op);
 			Expr(
-#line  1710 "cs.ATG" 
+#line  1722 "cs.ATG" 
 out val);
 
-#line  1710 "cs.ATG" 
+#line  1722 "cs.ATG" 
 			expr = new AssignmentExpression(expr, op, val); 
 		} else if (la.kind == 10 || la.kind == 12 || la.kind == 19) {
 
-#line  1711 "cs.ATG" 
+#line  1723 "cs.ATG" 
 			if (mustBeAssignment) Error("error in assignment."); 
-		} else SynErr(170);
+		} else SynErr(171);
 
-#line  1712 "cs.ATG" 
+#line  1724 "cs.ATG" 
 		stmt = new StatementExpression(expr); 
 	}
 
 	void SwitchSection(
-#line  1610 "cs.ATG" 
+#line  1622 "cs.ATG" 
 out Statement stmt) {
 
-#line  1612 "cs.ATG" 
+#line  1624 "cs.ATG" 
 		SwitchSection switchSection = new SwitchSection();
 		Expression expr;
 		
 		SwitchLabel(
-#line  1616 "cs.ATG" 
+#line  1628 "cs.ATG" 
 out expr);
 
-#line  1616 "cs.ATG" 
+#line  1628 "cs.ATG" 
 		switchSection.SwitchLabels.Add(expr); 
 		while (la.kind == 54 || la.kind == 62) {
 			SwitchLabel(
-#line  1616 "cs.ATG" 
+#line  1628 "cs.ATG" 
 out expr);
 
-#line  1616 "cs.ATG" 
+#line  1628 "cs.ATG" 
 			switchSection.SwitchLabels.Add(expr); 
 		}
 
-#line  1617 "cs.ATG" 
+#line  1629 "cs.ATG" 
 		compilationUnit.BlockStart(switchSection); 
 		Statement();
 		while (StartOf(20)) {
 			Statement();
 		}
 
-#line  1620 "cs.ATG" 
+#line  1632 "cs.ATG" 
 		compilationUnit.BlockEnd();
 		stmt = switchSection;
 		
 	}
 
 	void ForInitializer(
-#line  1591 "cs.ATG" 
+#line  1603 "cs.ATG" 
 out ArrayList initializer) {
 
-#line  1593 "cs.ATG" 
+#line  1605 "cs.ATG" 
 		Statement stmt; 
 		initializer = new ArrayList();
 		
 		if (
-#line  1597 "cs.ATG" 
+#line  1609 "cs.ATG" 
 IsLocalVarDecl()) {
 			LocalVariableDecl(
-#line  1597 "cs.ATG" 
+#line  1609 "cs.ATG" 
 out stmt);
 
-#line  1597 "cs.ATG" 
+#line  1609 "cs.ATG" 
 			initializer.Add(stmt);
 		} else if (StartOf(4)) {
 			StatementExpr(
-#line  1598 "cs.ATG" 
+#line  1610 "cs.ATG" 
 out stmt);
 
-#line  1598 "cs.ATG" 
+#line  1610 "cs.ATG" 
 			initializer.Add(stmt);
 			while (la.kind == 12) {
 				lexer.NextToken();
 				StatementExpr(
-#line  1598 "cs.ATG" 
+#line  1610 "cs.ATG" 
 out stmt);
 
-#line  1598 "cs.ATG" 
+#line  1610 "cs.ATG" 
 				initializer.Add(stmt);
 			}
 
-#line  1598 "cs.ATG" 
+#line  1610 "cs.ATG" 
 			initializer.Add(stmt);
-		} else SynErr(171);
+		} else SynErr(172);
 	}
 
 	void ForIterator(
-#line  1601 "cs.ATG" 
+#line  1613 "cs.ATG" 
 out ArrayList iterator) {
 
-#line  1603 "cs.ATG" 
+#line  1615 "cs.ATG" 
 		Statement stmt; 
 		iterator = new ArrayList();
 		
 		StatementExpr(
-#line  1607 "cs.ATG" 
+#line  1619 "cs.ATG" 
 out stmt);
 
-#line  1607 "cs.ATG" 
+#line  1619 "cs.ATG" 
 		iterator.Add(stmt);
 		while (la.kind == 12) {
 			lexer.NextToken();
 			StatementExpr(
-#line  1607 "cs.ATG" 
+#line  1619 "cs.ATG" 
 out stmt);
 
-#line  1607 "cs.ATG" 
+#line  1619 "cs.ATG" 
 			iterator.Add(stmt); 
 		}
 	}
 
 	void GotoStatement(
-#line  1669 "cs.ATG" 
+#line  1681 "cs.ATG" 
 out Statement stmt) {
 
-#line  1670 "cs.ATG" 
+#line  1682 "cs.ATG" 
 		Expression expr; stmt = null; 
 		Expect(77);
 		if (la.kind == 1) {
 			lexer.NextToken();
 
-#line  1674 "cs.ATG" 
+#line  1686 "cs.ATG" 
 			stmt = new GotoStatement(t.val); 
 			Expect(10);
 		} else if (la.kind == 54) {
 			lexer.NextToken();
 			Expr(
-#line  1675 "cs.ATG" 
+#line  1687 "cs.ATG" 
 out expr);
 			Expect(10);
 
-#line  1675 "cs.ATG" 
+#line  1687 "cs.ATG" 
 			stmt = new GotoCaseStatement(expr); 
 		} else if (la.kind == 62) {
 			lexer.NextToken();
 			Expect(10);
 
-#line  1676 "cs.ATG" 
+#line  1688 "cs.ATG" 
 			stmt = new GotoCaseStatement(null); 
-		} else SynErr(172);
+		} else SynErr(173);
 	}
 
 	void TryStatement(
-#line  1632 "cs.ATG" 
+#line  1644 "cs.ATG" 
 out Statement tryStatement) {
 
-#line  1634 "cs.ATG" 
+#line  1646 "cs.ATG" 
 		Statement blockStmt = null, finallyStmt = null;
 		ArrayList catchClauses = null;
 		
 		Expect(113);
 		Block(
-#line  1638 "cs.ATG" 
+#line  1650 "cs.ATG" 
 out blockStmt);
 		if (la.kind == 55) {
 			CatchClauses(
-#line  1640 "cs.ATG" 
+#line  1652 "cs.ATG" 
 out catchClauses);
 			if (la.kind == 72) {
 				lexer.NextToken();
 				Block(
-#line  1640 "cs.ATG" 
+#line  1652 "cs.ATG" 
 out finallyStmt);
 			}
 		} else if (la.kind == 72) {
 			lexer.NextToken();
 			Block(
-#line  1641 "cs.ATG" 
+#line  1653 "cs.ATG" 
 out finallyStmt);
-		} else SynErr(173);
+		} else SynErr(174);
 
-#line  1644 "cs.ATG" 
+#line  1656 "cs.ATG" 
 		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
 		
 	}
 
 	void ResourceAcquisition(
-#line  1680 "cs.ATG" 
+#line  1692 "cs.ATG" 
 out Statement stmt) {
 
-#line  1682 "cs.ATG" 
+#line  1694 "cs.ATG" 
 		stmt = null;
 		Expression expr;
 		
 		if (
-#line  1687 "cs.ATG" 
+#line  1699 "cs.ATG" 
 IsLocalVarDecl()) {
 			LocalVariableDecl(
-#line  1687 "cs.ATG" 
+#line  1699 "cs.ATG" 
 out stmt);
 		} else if (StartOf(4)) {
 			Expr(
-#line  1688 "cs.ATG" 
+#line  1700 "cs.ATG" 
 out expr);
 
-#line  1692 "cs.ATG" 
+#line  1704 "cs.ATG" 
 			stmt = new StatementExpression(expr); 
-		} else SynErr(174);
+		} else SynErr(175);
 	}
 
 	void SwitchLabel(
-#line  1625 "cs.ATG" 
+#line  1637 "cs.ATG" 
 out Expression expr) {
 
-#line  1626 "cs.ATG" 
+#line  1638 "cs.ATG" 
 		expr = null; 
 		if (la.kind == 54) {
 			lexer.NextToken();
 			Expr(
-#line  1628 "cs.ATG" 
+#line  1640 "cs.ATG" 
 out expr);
 			Expect(9);
 		} else if (la.kind == 62) {
 			lexer.NextToken();
 			Expect(9);
-		} else SynErr(175);
+		} else SynErr(176);
 	}
 
 	void CatchClauses(
-#line  1649 "cs.ATG" 
+#line  1661 "cs.ATG" 
 out ArrayList catchClauses) {
 
-#line  1651 "cs.ATG" 
+#line  1663 "cs.ATG" 
 		catchClauses = new ArrayList();
 		
 		Expect(55);
 
-#line  1654 "cs.ATG" 
+#line  1666 "cs.ATG" 
 		string name;
 		string identifier;
 		Statement stmt; 
 		
 		if (la.kind == 14) {
 			Block(
-#line  1660 "cs.ATG" 
+#line  1672 "cs.ATG" 
 out stmt);
 
-#line  1660 "cs.ATG" 
+#line  1672 "cs.ATG" 
 			catchClauses.Add(new CatchClause(stmt)); 
 		} else if (la.kind == 18) {
 			lexer.NextToken();
 			ClassType(
-#line  1662 "cs.ATG" 
+#line  1674 "cs.ATG" 
 out name);
 
-#line  1662 "cs.ATG" 
+#line  1674 "cs.ATG" 
 			identifier = null; 
 			if (la.kind == 1) {
 				lexer.NextToken();
 
-#line  1662 "cs.ATG" 
+#line  1674 "cs.ATG" 
 				identifier = t.val; 
 			}
 			Expect(19);
 			Block(
-#line  1662 "cs.ATG" 
+#line  1674 "cs.ATG" 
 out stmt);
 
-#line  1662 "cs.ATG" 
+#line  1674 "cs.ATG" 
 			catchClauses.Add(new CatchClause(name, identifier, stmt)); 
 			while (
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 IsTypedCatch()) {
 				Expect(55);
 				Expect(18);
 				ClassType(
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 out name);
 
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 				identifier = null; 
 				if (la.kind == 1) {
 					lexer.NextToken();
 
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 					identifier = t.val; 
 				}
 				Expect(19);
 				Block(
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 out stmt);
 
-#line  1663 "cs.ATG" 
+#line  1675 "cs.ATG" 
 				catchClauses.Add(new CatchClause(name, identifier, stmt)); 
 			}
 			if (la.kind == 55) {
 				lexer.NextToken();
 				Block(
-#line  1665 "cs.ATG" 
+#line  1677 "cs.ATG" 
 out stmt);
 
-#line  1665 "cs.ATG" 
+#line  1677 "cs.ATG" 
 				catchClauses.Add(new CatchClause(stmt)); 
 			}
-		} else SynErr(176);
+		} else SynErr(177);
 	}
 
 	void UnaryExpr(
-#line  1728 "cs.ATG" 
+#line  1740 "cs.ATG" 
 out Expression uExpr) {
 
-#line  1730 "cs.ATG" 
+#line  1742 "cs.ATG" 
 		TypeReference type = null;
 		Expression expr;
 		ArrayList  expressions = new ArrayList();
 		uExpr = null;
 		
-		while (StartOf(24) || 
-#line  1752 "cs.ATG" 
+		while (StartOf(26) || 
+#line  1764 "cs.ATG" 
 IsTypeCast()) {
 			if (la.kind == 4) {
 				lexer.NextToken();
 
-#line  1737 "cs.ATG" 
+#line  1749 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Plus)); 
 			} else if (la.kind == 5) {
 				lexer.NextToken();
 
-#line  1738 "cs.ATG" 
+#line  1750 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Minus)); 
 			} else if (la.kind == 22) {
 				lexer.NextToken();
 
-#line  1739 "cs.ATG" 
+#line  1751 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Not)); 
 			} else if (la.kind == 25) {
 				lexer.NextToken();
 
-#line  1740 "cs.ATG" 
+#line  1752 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.BitNot)); 
 			} else if (la.kind == 6) {
 				lexer.NextToken();
 
-#line  1741 "cs.ATG" 
+#line  1753 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Star)); 
 			} else if (la.kind == 29) {
 				lexer.NextToken();
 
-#line  1742 "cs.ATG" 
+#line  1754 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Increment)); 
 			} else if (la.kind == 30) {
 				lexer.NextToken();
 
-#line  1743 "cs.ATG" 
+#line  1755 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.Decrement)); 
 			} else if (la.kind == 26) {
 				lexer.NextToken();
 
-#line  1744 "cs.ATG" 
+#line  1756 "cs.ATG" 
 				expressions.Add(new UnaryOperatorExpression(UnaryOperatorType.BitWiseAnd)); 
 			} else {
 				Expect(18);
 				Type(
-#line  1752 "cs.ATG" 
+#line  1764 "cs.ATG" 
 out type);
 				Expect(19);
 
-#line  1752 "cs.ATG" 
+#line  1764 "cs.ATG" 
 				expressions.Add(new CastExpression(type)); 
 			}
 		}
 		PrimaryExpr(
-#line  1755 "cs.ATG" 
+#line  1767 "cs.ATG" 
 out expr);
 
-#line  1755 "cs.ATG" 
+#line  1767 "cs.ATG" 
 		for (int i = 0; i < expressions.Count; ++i) {
 		Expression nextExpression = i + 1 < expressions.Count ? (Expression)expressions[i + 1] : expr;
 		if (expressions[i] is CastExpression) {
@@ -3974,33 +4016,33 @@
 	}
 
 	void ConditionalOrExpr(
-#line  1857 "cs.ATG" 
+#line  1869 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1858 "cs.ATG" 
+#line  1870 "cs.ATG" 
 		Expression expr;   
 		ConditionalAndExpr(
-#line  1860 "cs.ATG" 
+#line  1872 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 24) {
 			lexer.NextToken();
 			UnaryExpr(
-#line  1860 "cs.ATG" 
+#line  1872 "cs.ATG" 
 out expr);
 			ConditionalAndExpr(
-#line  1860 "cs.ATG" 
+#line  1872 "cs.ATG" 
 ref expr);
 
-#line  1860 "cs.ATG" 
+#line  1872 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalOr, expr);  
 		}
 	}
 
 	void PrimaryExpr(
-#line  1772 "cs.ATG" 
+#line  1784 "cs.ATG" 
 out Expression pexpr) {
 
-#line  1774 "cs.ATG" 
+#line  1786 "cs.ATG" 
 		TypeReference type = null;
 		bool isArrayCreation = false;
 		Expression expr;
@@ -4010,46 +4052,46 @@
 		case 112: {
 			lexer.NextToken();
 
-#line  1781 "cs.ATG" 
+#line  1793 "cs.ATG" 
 			pexpr = new PrimitiveExpression(true, "true");  
 			break;
 		}
 		case 71: {
 			lexer.NextToken();
 
-#line  1782 "cs.ATG" 
+#line  1794 "cs.ATG" 
 			pexpr = new PrimitiveExpression(false, "false"); 
 			break;
 		}
 		case 89: {
 			lexer.NextToken();
 
-#line  1783 "cs.ATG" 
+#line  1795 "cs.ATG" 
 			pexpr = new PrimitiveExpression(null, "null");  
 			break;
 		}
 		case 2: {
 			lexer.NextToken();
 
-#line  1784 "cs.ATG" 
+#line  1796 "cs.ATG" 
 			pexpr = new PrimitiveExpression(t.literalValue, t.val);  
 			break;
 		}
 		case 1: {
 			lexer.NextToken();
 
-#line  1786 "cs.ATG" 
+#line  1798 "cs.ATG" 
 			pexpr = new IdentifierExpression(t.val); 
 			break;
 		}
 		case 18: {
 			lexer.NextToken();
 			Expr(
-#line  1788 "cs.ATG" 
+#line  1800 "cs.ATG" 
 out expr);
 			Expect(19);
 
-#line  1788 "cs.ATG" 
+#line  1800 "cs.ATG" 
 			pexpr = new ParenthesizedExpression(expr); 
 			break;
 		}
@@ -4117,208 +4159,208 @@
 			}
 			}
 
-#line  1794 "cs.ATG" 
+#line  1806 "cs.ATG" 
 			string val = t.val; t.val = ""; 
 			Expect(13);
 			Expect(1);
 
-#line  1794 "cs.ATG" 
+#line  1806 "cs.ATG" 
 			pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); 
 			break;
 		}
 		case 110: {
 			lexer.NextToken();
 
-#line  1796 "cs.ATG" 
+#line  1808 "cs.ATG" 
 			pexpr = new ThisReferenceExpression(); 
 			break;
 		}
 		case 50: {
 			lexer.NextToken();
 
-#line  1798 "cs.ATG" 
+#line  1810 "cs.ATG" 
 			Expression retExpr = new BaseReferenceExpression(); 
 			if (la.kind == 13) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  1800 "cs.ATG" 
+#line  1812 "cs.ATG" 
 				retExpr = new FieldReferenceExpression(retExpr, t.val); 
 			} else if (la.kind == 16) {
 				lexer.NextToken();
 				Expr(
-#line  1801 "cs.ATG" 
+#line  1813 "cs.ATG" 
 out expr);
 
-#line  1801 "cs.ATG" 
+#line  1813 "cs.ATG" 
 				ArrayList indices = new ArrayList(); indices.Add(expr); 
 				while (la.kind == 12) {
 					lexer.NextToken();
 					Expr(
-#line  1802 "cs.ATG" 
+#line  1814 "cs.ATG" 
 out expr);
 
-#line  1802 "cs.ATG" 
+#line  1814 "cs.ATG" 
 					indices.Add(expr); 
 				}
 				Expect(17);
 
-#line  1803 "cs.ATG" 
+#line  1815 "cs.ATG" 
 				retExpr = new IndexerExpression(retExpr, indices); 
-			} else SynErr(177);
+			} else SynErr(178);
 
-#line  1804 "cs.ATG" 
+#line  1816 "cs.ATG" 
 			pexpr = retExpr; 
 			break;
 		}
 		case 88: {
 			lexer.NextToken();
 			NonArrayType(
-#line  1805 "cs.ATG" 
+#line  1817 "cs.ATG" 
 out type);
 
-#line  1805 "cs.ATG" 
+#line  1817 "cs.ATG" 
 			ArrayList parameters = new ArrayList(); 
 			if (la.kind == 18) {
 				lexer.NextToken();
 
-#line  1810 "cs.ATG" 
+#line  1822 "cs.ATG" 
 				ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters); 
 				if (StartOf(21)) {
 					Argument(
-#line  1810 "cs.ATG" 
+#line  1822 "cs.ATG" 
 out expr);
 
-#line  1810 "cs.ATG" 
+#line  1822 "cs.ATG" 
 					parameters.Add(expr); 
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Argument(
-#line  1811 "cs.ATG" 
+#line  1823 "cs.ATG" 
 out expr);
 
-#line  1811 "cs.ATG" 
+#line  1823 "cs.ATG" 
 						parameters.Add(expr); 
 					}
 				}
 				Expect(19);
 
-#line  1811 "cs.ATG" 
+#line  1823 "cs.ATG" 
 				pexpr = oce; 
 			} else if (la.kind == 16) {
 
-#line  1813 "cs.ATG" 
+#line  1825 "cs.ATG" 
 				isArrayCreation = true; ArrayCreateExpression ace = new ArrayCreateExpression(type); pexpr = ace; 
 				lexer.NextToken();
 
-#line  1814 "cs.ATG" 
+#line  1826 "cs.ATG" 
 				int dims = 0; ArrayList rank = new ArrayList(); ArrayList parameterExpression = new ArrayList(); 
 				if (StartOf(4)) {
 					Expr(
-#line  1816 "cs.ATG" 
+#line  1828 "cs.ATG" 
 out expr);
 
-#line  1816 "cs.ATG" 
+#line  1828 "cs.ATG" 
 					parameterExpression.Add(expr); 
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Expr(
-#line  1816 "cs.ATG" 
+#line  1828 "cs.ATG" 
 out expr);
 
-#line  1816 "cs.ATG" 
+#line  1828 "cs.ATG" 
 						parameterExpression.Add(expr); 
 					}
 					Expect(17);
 
-#line  1816 "cs.ATG" 
+#line  1828 "cs.ATG" 
 					parameters.Add(new ArrayCreationParameter(parameterExpression)); ace.Parameters = parameters; 
 					while (
-#line  1817 "cs.ATG" 
+#line  1829 "cs.ATG" 
 IsDims()) {
 						Expect(16);
 
-#line  1817 "cs.ATG" 
+#line  1829 "cs.ATG" 
 						dims =0;
 						while (la.kind == 12) {
 							lexer.NextToken();
 
-#line  1817 "cs.ATG" 
+#line  1829 "cs.ATG" 
 							dims++;
 						}
 
-#line  1817 "cs.ATG" 
+#line  1829 "cs.ATG" 
 						rank.Add(dims); parameters.Add(new ArrayCreationParameter(dims)); 
 						Expect(17);
 					}
 
-#line  1818 "cs.ATG" 
+#line  1830 "cs.ATG" 
 					if (rank.Count > 0) { ace.Rank = (int[])rank.ToArray(typeof (int)); } 
 					if (la.kind == 14) {
 						ArrayInitializer(
-#line  1819 "cs.ATG" 
+#line  1831 "cs.ATG" 
 out expr);
 
-#line  1819 "cs.ATG" 
+#line  1831 "cs.ATG" 
 						ace.ArrayInitializer = (ArrayInitializerExpression)expr; 
 					}
 				} else if (la.kind == 12 || la.kind == 17) {
 					while (la.kind == 12) {
 						lexer.NextToken();
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 						dims++;
 					}
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 					parameters.Add(new ArrayCreationParameter(dims)); 
 					Expect(17);
 					while (
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 IsDims()) {
 						Expect(16);
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 						dims =0;
 						while (la.kind == 12) {
 							lexer.NextToken();
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 							dims++;
 						}
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 						parameters.Add(new ArrayCreationParameter(dims)); 
 						Expect(17);
 					}
 					ArrayInitializer(
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 out expr);
 
-#line  1821 "cs.ATG" 
+#line  1833 "cs.ATG" 
 					ace.ArrayInitializer = (ArrayInitializerExpression)expr; ace.Parameters = parameters; 
-				} else SynErr(178);
-			} else SynErr(179);
+				} else SynErr(179);
+			} else SynErr(180);
 			break;
 		}
 		case 114: {
 			lexer.NextToken();
 			Expect(18);
 			if (
-#line  1827 "cs.ATG" 
+#line  1839 "cs.ATG" 
 NotVoidPointer()) {
 				Expect(122);
 
-#line  1827 "cs.ATG" 
+#line  1839 "cs.ATG" 
 				type = new TypeReference("void"); 
 			} else if (StartOf(8)) {
 				Type(
-#line  1828 "cs.ATG" 
+#line  1840 "cs.ATG" 
 out type);
-			} else SynErr(180);
+			} else SynErr(181);
 			Expect(19);
 
-#line  1829 "cs.ATG" 
+#line  1841 "cs.ATG" 
 			pexpr = new TypeOfExpression(type); 
 			break;
 		}
@@ -4326,11 +4368,11 @@
 			lexer.NextToken();
 			Expect(18);
 			Type(
-#line  1830 "cs.ATG" 
+#line  1842 "cs.ATG" 
 out type);
 			Expect(19);
 
-#line  1830 "cs.ATG" 
+#line  1842 "cs.ATG" 
 			pexpr = new SizeOfExpression(type); 
 			break;
 		}
@@ -4338,11 +4380,11 @@
 			lexer.NextToken();
 			Expect(18);
 			Expr(
-#line  1831 "cs.ATG" 
+#line  1843 "cs.ATG" 
 out expr);
 			Expect(19);
 
-#line  1831 "cs.ATG" 
+#line  1843 "cs.ATG" 
 			pexpr = new CheckedExpression(expr); 
 			break;
 		}
@@ -4350,365 +4392,365 @@
 			lexer.NextToken();
 			Expect(18);
 			Expr(
-#line  1832 "cs.ATG" 
+#line  1844 "cs.ATG" 
 out expr);
 			Expect(19);
 
-#line  1832 "cs.ATG" 
+#line  1844 "cs.ATG" 
 			pexpr = new CheckedExpression(expr); 
 			break;
 		}
-		default: SynErr(181); break;
+		default: SynErr(182); break;
 		}
-		while (StartOf(25)) {
+		while (StartOf(27)) {
 			if (la.kind == 29 || la.kind == 30) {
 				if (la.kind == 29) {
 					lexer.NextToken();
 
-#line  1836 "cs.ATG" 
+#line  1848 "cs.ATG" 
 					pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement); 
 				} else if (la.kind == 30) {
 					lexer.NextToken();
 
-#line  1837 "cs.ATG" 
+#line  1849 "cs.ATG" 
 					pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement); 
-				} else SynErr(182);
+				} else SynErr(183);
 			} else if (la.kind == 47) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  1840 "cs.ATG" 
+#line  1852 "cs.ATG" 
 				pexpr = new PointerReferenceExpression(pexpr, t.val); 
 			} else if (la.kind == 13) {
 				lexer.NextToken();
 				Expect(1);
 
-#line  1841 "cs.ATG" 
+#line  1853 "cs.ATG" 
 				pexpr = new FieldReferenceExpression(pexpr, t.val);
 			} else if (la.kind == 18) {
 				lexer.NextToken();
 
-#line  1843 "cs.ATG" 
+#line  1855 "cs.ATG" 
 				ArrayList parameters = new ArrayList(); 
 				if (StartOf(21)) {
 					Argument(
-#line  1844 "cs.ATG" 
+#line  1856 "cs.ATG" 
 out expr);
 
-#line  1844 "cs.ATG" 
+#line  1856 "cs.ATG" 
 					parameters.Add(expr); 
 					while (la.kind == 12) {
 						lexer.NextToken();
 						Argument(
-#line  1845 "cs.ATG" 
+#line  1857 "cs.ATG" 
 out expr);
 
-#line  1845 "cs.ATG" 
+#line  1857 "cs.ATG" 
 						parameters.Add(expr); 
 					}
 				}
 				Expect(19);
 
-#line  1846 "cs.ATG" 
+#line  1858 "cs.ATG" 
 				pexpr = new InvocationExpression(pexpr, parameters); 
 			} else {
 
-#line  1848 "cs.ATG" 
+#line  1860 "cs.ATG" 
 				if (isArrayCreation) Error("element access not allow on array creation");
 				ArrayList indices = new ArrayList();
 				
 				lexer.NextToken();
 				Expr(
-#line  1851 "cs.ATG" 
+#line  1863 "cs.ATG" 
 out expr);
 
-#line  1851 "cs.ATG" 
+#line  1863 "cs.ATG" 
 				indices.Add(expr); 
 				while (la.kind == 12) {
 					lexer.NextToken();
 					Expr(
-#line  1852 "cs.ATG" 
+#line  1864 "cs.ATG" 
 out expr);
 
-#line  1852 "cs.ATG" 
+#line  1864 "cs.ATG" 
 					indices.Add(expr); 
 				}
 				Expect(17);
 
-#line  1853 "cs.ATG" 
+#line  1865 "cs.ATG" 
 				pexpr = new IndexerExpression(pexpr, indices); 
 			}
 		}
 	}
 
 	void ConditionalAndExpr(
-#line  1863 "cs.ATG" 
+#line  1875 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1864 "cs.ATG" 
+#line  1876 "cs.ATG" 
 		Expression expr; 
 		InclusiveOrExpr(
-#line  1866 "cs.ATG" 
+#line  1878 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 23) {
 			lexer.NextToken();
 			UnaryExpr(
-#line  1866 "cs.ATG" 
+#line  1878 "cs.ATG" 
 out expr);
 			InclusiveOrExpr(
-#line  1866 "cs.ATG" 
+#line  1878 "cs.ATG" 
 ref expr);
 
-#line  1866 "cs.ATG" 
+#line  1878 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.LogicalAnd, expr);  
 		}
 	}
 
 	void InclusiveOrExpr(
-#line  1869 "cs.ATG" 
+#line  1881 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1870 "cs.ATG" 
+#line  1882 "cs.ATG" 
 		Expression expr; 
 		ExclusiveOrExpr(
-#line  1872 "cs.ATG" 
+#line  1884 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 27) {
 			lexer.NextToken();
 			UnaryExpr(
-#line  1872 "cs.ATG" 
+#line  1884 "cs.ATG" 
 out expr);
 			ExclusiveOrExpr(
-#line  1872 "cs.ATG" 
+#line  1884 "cs.ATG" 
 ref expr);
 
-#line  1872 "cs.ATG" 
+#line  1884 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr);  
 		}
 	}
 
 	void ExclusiveOrExpr(
-#line  1875 "cs.ATG" 
+#line  1887 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1876 "cs.ATG" 
+#line  1888 "cs.ATG" 
 		Expression expr; 
 		AndExpr(
-#line  1878 "cs.ATG" 
+#line  1890 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 28) {
 			lexer.NextToken();
 			UnaryExpr(
-#line  1878 "cs.ATG" 
+#line  1890 "cs.ATG" 
 out expr);
 			AndExpr(
-#line  1878 "cs.ATG" 
+#line  1890 "cs.ATG" 
 ref expr);
 
-#line  1878 "cs.ATG" 
+#line  1890 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr);  
 		}
 	}
 
 	void AndExpr(
-#line  1881 "cs.ATG" 
+#line  1893 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1882 "cs.ATG" 
+#line  1894 "cs.ATG" 
 		Expression expr; 
 		EqualityExpr(
-#line  1884 "cs.ATG" 
+#line  1896 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 26) {
 			lexer.NextToken();
 			UnaryExpr(
-#line  1884 "cs.ATG" 
+#line  1896 "cs.ATG" 
 out expr);
 			EqualityExpr(
-#line  1884 "cs.ATG" 
+#line  1896 "cs.ATG" 
 ref expr);
 
-#line  1884 "cs.ATG" 
+#line  1896 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr);  
 		}
 	}
 
 	void EqualityExpr(
-#line  1887 "cs.ATG" 
+#line  1899 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1889 "cs.ATG" 
+#line  1901 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		RelationalExpr(
-#line  1893 "cs.ATG" 
+#line  1905 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 31 || la.kind == 32) {
 			if (la.kind == 32) {
 				lexer.NextToken();
 
-#line  1896 "cs.ATG" 
+#line  1908 "cs.ATG" 
 				op = BinaryOperatorType.InEquality; 
 			} else {
 				lexer.NextToken();
 
-#line  1897 "cs.ATG" 
+#line  1909 "cs.ATG" 
 				op = BinaryOperatorType.Equality; 
 			}
 			UnaryExpr(
-#line  1899 "cs.ATG" 
+#line  1911 "cs.ATG" 
 out expr);
 			RelationalExpr(
-#line  1899 "cs.ATG" 
+#line  1911 "cs.ATG" 
 ref expr);
 
-#line  1899 "cs.ATG" 
+#line  1911 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void RelationalExpr(
-#line  1903 "cs.ATG" 
+#line  1915 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1905 "cs.ATG" 
+#line  1917 "cs.ATG" 
 		TypeReference type;
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		ShiftExpr(
-#line  1910 "cs.ATG" 
+#line  1922 "cs.ATG" 
 ref outExpr);
-		while (StartOf(26)) {
-			if (StartOf(27)) {
+		while (StartOf(28)) {
+			if (StartOf(29)) {
 				if (la.kind == 21) {
 					lexer.NextToken();
 
-#line  1913 "cs.ATG" 
+#line  1925 "cs.ATG" 
 					op = BinaryOperatorType.LessThan; 
 				} else if (la.kind == 20) {
 					lexer.NextToken();
 
-#line  1914 "cs.ATG" 
+#line  1926 "cs.ATG" 
 					op = BinaryOperatorType.GreaterThan; 
 				} else if (la.kind == 34) {
 					lexer.NextToken();
 
-#line  1915 "cs.ATG" 
+#line  1927 "cs.ATG" 
 					op = BinaryOperatorType.LessThanOrEqual; 
 				} else if (la.kind == 33) {
 					lexer.NextToken();
 
-#line  1916 "cs.ATG" 
+#line  1928 "cs.ATG" 
 					op = BinaryOperatorType.GreaterThanOrEqual; 
-				} else SynErr(183);
+				} else SynErr(184);
 				UnaryExpr(
-#line  1918 "cs.ATG" 
+#line  1930 "cs.ATG" 
 out expr);
 				ShiftExpr(
-#line  1918 "cs.ATG" 
+#line  1930 "cs.ATG" 
 ref expr);
 
-#line  1918 "cs.ATG" 
+#line  1930 "cs.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 			} else {
 				if (la.kind == 84) {
 					lexer.NextToken();
 
-#line  1921 "cs.ATG" 
+#line  1933 "cs.ATG" 
 					op = BinaryOperatorType.IS; 
 				} else if (la.kind == 49) {
 					lexer.NextToken();
 
-#line  1922 "cs.ATG" 
+#line  1934 "cs.ATG" 
 					op = BinaryOperatorType.AS; 
-				} else SynErr(184);
+				} else SynErr(185);
 				Type(
-#line  1924 "cs.ATG" 
+#line  1936 "cs.ATG" 
 out type);
 
-#line  1924 "cs.ATG" 
+#line  1936 "cs.ATG" 
 				outExpr = new BinaryOperatorExpression(outExpr, op, new TypeReferenceExpression(type)); 
 			}
 		}
 	}
 
 	void ShiftExpr(
-#line  1928 "cs.ATG" 
+#line  1940 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1930 "cs.ATG" 
+#line  1942 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		AdditiveExpr(
-#line  1934 "cs.ATG" 
+#line  1946 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 35 || la.kind == 36) {
 			if (la.kind == 35) {
 				lexer.NextToken();
 
-#line  1937 "cs.ATG" 
+#line  1949 "cs.ATG" 
 				op = BinaryOperatorType.ShiftLeft; 
 			} else {
 				lexer.NextToken();
 
-#line  1938 "cs.ATG" 
+#line  1950 "cs.ATG" 
 				op = BinaryOperatorType.ShiftRight; 
 			}
 			UnaryExpr(
-#line  1940 "cs.ATG" 
+#line  1952 "cs.ATG" 
 out expr);
 			AdditiveExpr(
-#line  1940 "cs.ATG" 
+#line  1952 "cs.ATG" 
 ref expr);
 
-#line  1940 "cs.ATG" 
+#line  1952 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void AdditiveExpr(
-#line  1944 "cs.ATG" 
+#line  1956 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1946 "cs.ATG" 
+#line  1958 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
 		MultiplicativeExpr(
-#line  1950 "cs.ATG" 
+#line  1962 "cs.ATG" 
 ref outExpr);
 		while (la.kind == 4 || la.kind == 5) {
 			if (la.kind == 4) {
 				lexer.NextToken();
 
-#line  1953 "cs.ATG" 
+#line  1965 "cs.ATG" 
 				op = BinaryOperatorType.Add; 
 			} else {
 				lexer.NextToken();
 
-#line  1954 "cs.ATG" 
+#line  1966 "cs.ATG" 
 				op = BinaryOperatorType.Subtract; 
 			}
 			UnaryExpr(
-#line  1956 "cs.ATG" 
+#line  1968 "cs.ATG" 
 out expr);
 			MultiplicativeExpr(
-#line  1956 "cs.ATG" 
+#line  1968 "cs.ATG" 
 ref expr);
 
-#line  1956 "cs.ATG" 
+#line  1968 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr);  
 		}
 	}
 
 	void MultiplicativeExpr(
-#line  1960 "cs.ATG" 
+#line  1972 "cs.ATG" 
 ref Expression outExpr) {
 
-#line  1962 "cs.ATG" 
+#line  1974 "cs.ATG" 
 		Expression expr;
 		BinaryOperatorType op = BinaryOperatorType.None;
 		
@@ -4716,24 +4758,24 @@
 			if (la.kind == 6) {
 				lexer.NextToken();
 
-#line  1968 "cs.ATG" 
+#line  1980 "cs.ATG" 
 				op = BinaryOperatorType.Multiply; 
 			} else if (la.kind == 7) {
 				lexer.NextToken();
 
-#line  1969 "cs.ATG" 
+#line  1981 "cs.ATG" 
 				op = BinaryOperatorType.Divide; 
 			} else {
 				lexer.NextToken();
 
-#line  1970 "cs.ATG" 
+#line  1982 "cs.ATG" 
 				op = BinaryOperatorType.Modulus; 
 			}
 			UnaryExpr(
-#line  1972 "cs.ATG" 
+#line  1984 "cs.ATG" 
 out expr);
 
-#line  1972 "cs.ATG" 
+#line  1984 "cs.ATG" 
 			outExpr = new BinaryOperatorExpression(outExpr, op, expr); 
 		}
 	}
@@ -4911,35 +4953,36 @@
 			case 153: s = "invalid InterfaceMemberDecl"; break;
 			case 154: s = "invalid SimpleType"; break;
 			case 155: s = "invalid NonArrayType"; break;
-			case 156: s = "invalid EventAccessorDecls"; break;
-			case 157: s = "invalid ConstructorInitializer"; break;
-			case 158: s = "invalid OverloadableOperator"; break;
-			case 159: s = "invalid AccessorDecls"; break;
-			case 160: s = "invalid InterfaceAccessors"; break;
+			case 156: s = "invalid AccessorModifier"; break;
+			case 157: s = "invalid EventAccessorDecls"; break;
+			case 158: s = "invalid ConstructorInitializer"; break;
+			case 159: s = "invalid OverloadableOperator"; break;
+			case 160: s = "invalid AccessorDecls"; break;
 			case 161: s = "invalid InterfaceAccessors"; break;
-			case 162: s = "invalid GetAccessorDecl"; break;
-			case 163: s = "invalid SetAccessorDecl"; break;
-			case 164: s = "invalid VariableInitializer"; break;
-			case 165: s = "invalid Statement"; break;
-			case 166: s = "invalid AssignmentOperator"; break;
-			case 167: s = "invalid LocalVariableInitializer"; break;
-			case 168: s = "invalid EmbeddedStatement"; break;
+			case 162: s = "invalid InterfaceAccessors"; break;
+			case 163: s = "invalid GetAccessorDecl"; break;
+			case 164: s = "invalid SetAccessorDecl"; break;
+			case 165: s = "invalid VariableInitializer"; break;
+			case 166: s = "invalid Statement"; break;
+			case 167: s = "invalid AssignmentOperator"; break;
+			case 168: s = "invalid LocalVariableInitializer"; break;
 			case 169: s = "invalid EmbeddedStatement"; break;
-			case 170: s = "invalid StatementExpr"; break;
-			case 171: s = "invalid ForInitializer"; break;
-			case 172: s = "invalid GotoStatement"; break;
-			case 173: s = "invalid TryStatement"; break;
-			case 174: s = "invalid ResourceAcquisition"; break;
-			case 175: s = "invalid SwitchLabel"; break;
-			case 176: s = "invalid CatchClauses"; break;
-			case 177: s = "invalid PrimaryExpr"; break;
+			case 170: s = "invalid EmbeddedStatement"; break;
+			case 171: s = "invalid StatementExpr"; break;
+			case 172: s = "invalid ForInitializer"; break;
+			case 173: s = "invalid GotoStatement"; break;
+			case 174: s = "invalid TryStatement"; break;
+			case 175: s = "invalid ResourceAcquisition"; break;
+			case 176: s = "invalid SwitchLabel"; break;
+			case 177: s = "invalid CatchClauses"; break;
 			case 178: s = "invalid PrimaryExpr"; break;
 			case 179: s = "invalid PrimaryExpr"; break;
 			case 180: s = "invalid PrimaryExpr"; break;
 			case 181: s = "invalid PrimaryExpr"; break;
 			case 182: s = "invalid PrimaryExpr"; break;
-			case 183: s = "invalid RelationalExpr"; break;
+			case 183: s = "invalid PrimaryExpr"; break;
 			case 184: s = "invalid RelationalExpr"; break;
+			case 185: s = "invalid RelationalExpr"; break;
 
 			default: s = "error " + errorNumber; break;
 		}
@@ -4969,6 +5012,8 @@
 	{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,x, x,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,x,T, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,T, x,x,x,x, x,x,x},
 	{x,T,T,x, T,T,T,x, x,x,T,x, x,x,T,x, x,x,T,x, x,x,T,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, T,T,x,T, T,T,x,x, T,T,x,x, x,x,x,T, x,T,T,T, T,T,T,x, x,T,x,x, x,T,T,x, T,T,T,x, x,x,x,x, x,x,x,x, T,T,x,T, T,x,x,T, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, T,x,x},
 	{x,T,T,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,T,x, x,x,T,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,T,x,x, T,T,x,x, x,T,x,x, x,T,x,x, x,x,x,T, x,x,T,x, x,x,x,x, x,T,x,x, x,x,T,x, T,T,T,x, T,x,x,x, x,x,x,T, x,T,x,T, T,x,x,T, x,x,T,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x},
+	{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
+	{x,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,T, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},
 	{x,T,T,x, T,T,T,x, x,x,T,x, x,x,T,x, x,x,T,x, x,x,T,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, T,T,x,x, T,T,x,x, T,T,x,x, T,T,x,x, x,x,x,T, x,T,T,T, T,T,T,x, x,T,x,x, x,T,T,x, T,T,T,x, x,x,x,x, x,x,x,x, T,T,x,T, T,x,x,T, x,T,T,T, T,T,T,T, T,T,T,T, T,x,x,x, T,x,x},
 	{x,T,T,x, T,T,T,x, x,x,x,x, x,x,T,x, x,x,T,x, x,x,T,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,T, x,T,x,x, T,T,x,x, x,T,x,x, x,T,x,x, x,x,x,T, x,x,T,x, x,x,x,x, x,T,x,x, x,x,T,x, T,T,T,x, x,x,x,x, x,x,x,x, x,T,x,T, T,T,x,T, x,x,T,x, T,x,T,T, T,T,x,T, x,x,x,x, x,x,x},
 	{x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,T,x, x,T,T,x, x,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x},

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/cs.ATG
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/cs.ATG	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/Parser/generated/cs.ATG	2005-03-30 23:08:24 UTC (rev 2402)
@@ -968,6 +968,14 @@
 	| "volatile"                       (. m.Add(Modifier.Volatile); .)
 .
 
+AccessorModifier<Modifiers m>
+=
+   "internal"                         (. m.Add(Modifier.Internal); .)
+   | "public"                         (. m.Add(Modifier.Public); .)
+   | "protected"                      (. m.Add(Modifier.Protected); .)
+   | "private"                        (. m.Add(Modifier.Private); .)
+.
+
 StructMemberDecl<Modifiers m, ArrayList attributes>
 (.
 	string qualident = null;
@@ -1264,43 +1272,47 @@
 AccessorDecls<out PropertyGetRegion getBlock, out PropertySetRegion setBlock>
 (.
 	ArrayList attributes = new ArrayList(); 
+	Modifiers m = new Modifiers (this);
 	AttributeSection section;
 	getBlock = null;
 	setBlock = null; 
 .)
 =
 	{ AttributeSection<out section> (. attributes.Add(section); .) }
+	{ AccessorModifier<m> }
 	(
 		IF (IdentIsGet())
-			GetAccessorDecl<out getBlock, attributes>
-			[                       (. attributes = new ArrayList(); .)
+			GetAccessorDecl<out getBlock, attributes, m.Modifier>
+			[                       (. attributes = new ArrayList(); m = new Modifiers (this); .)
 				{ AttributeSection<out section> (. attributes.Add(section); .) }
-				SetAccessorDecl<out setBlock, attributes>
+				{ AccessorModifier<m> }
+				SetAccessorDecl<out setBlock, attributes, m.Modifier>
 			]
 		| IF (IdentIsSet())
-			SetAccessorDecl<out setBlock, attributes>
-			[                        (. attributes = new ArrayList(); .)
+			SetAccessorDecl<out setBlock, attributes, m.Modifier>
+			[                        (. attributes = new ArrayList(); m = new Modifiers (this); .)
 				{ AttributeSection<out section> (. attributes.Add(section); .) }
-				GetAccessorDecl<out getBlock, attributes>
+				{ AccessorModifier<m> }
+				GetAccessorDecl<out getBlock, attributes, m.Modifier>
 			]
 		| ident (. Error("get or set accessor declaration expected"); .)
 	)
 .
 
-GetAccessorDecl<out PropertyGetRegion getBlock, ArrayList attributes>
+GetAccessorDecl<out PropertyGetRegion getBlock, ArrayList attributes, Modifier m>
 (. Statement stmt = null; .)
 =
 	ident /* "get" is not a keyword */
 	(. if (t.val != "get") Error("get expected"); .)
-	( Block<out stmt> | ";" ) (. getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); .)
+	( Block<out stmt> | ";" ) (. getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes, m); .)
 .
 
-SetAccessorDecl<out PropertySetRegion setBlock, ArrayList attributes>
+SetAccessorDecl<out PropertySetRegion setBlock, ArrayList attributes, Modifier m>
 (. Statement stmt = null; .)
 =
 	ident /* "set" is not a keyword */
 	(. if (t.val != "set") Error("set expected"); .)
-	( Block<out stmt> | ";" ) (. setBlock = new PropertySetRegion((BlockStatement)stmt, attributes); .)
+	( Block<out stmt> | ";" ) (. setBlock = new PropertySetRegion((BlockStatement)stmt, attributes, m); .)
 .
 
 EventAccessorDecls<out EventAddRegion addBlock, out EventRemoveRegion removeBlock>

Modified: trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/PrettyPrinter/PrettyPrintVisitor.cs
===================================================================
--- trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/PrettyPrinter/PrettyPrintVisitor.cs	2005-03-30 21:05:13 UTC (rev 2401)
+++ trunk/MonoDevelop/Core/src/ICSharpCode.SharpRefactory/src/PrettyPrinter/PrettyPrintVisitor.cs	2005-03-30 23:08:24 UTC (rev 2402)
@@ -596,6 +596,7 @@
 		{
 			this.VisitAttributes(getRegion.Attributes, data);
 			outputFormatter.Indent();
+			VisitModifier(getRegion.Modifier);
 			outputFormatter.PrintIdentifier("get");
 			if (getRegion.Block == null) {
 				outputFormatter.PrintToken(Tokens.Semicolon);
@@ -617,6 +618,7 @@
 		{
 			this.VisitAttributes(setRegion.Attributes, data);
 			outputFormatter.Indent();
+			VisitModifier(setRegion.Modifier);
 			outputFormatter.PrintIdentifier("set");
 			if (setRegion.Block == null) {
 				outputFormatter.PrintToken(Tokens.Semicolon);




More information about the Monodevelop-patches-list mailing list