parser.cs

全功能c#编译器

			}
		} else SynErr(211);

#line  1291 "VBNET.ATG" 
		fieldDeclaration.Add(f); 
	}

	void ConstantDeclarator(
#line  1227 "VBNET.ATG" 
ArrayList constantDeclaration) {

#line  1229 "VBNET.ATG" 
		Expression expr = null;
		TypeReference type = null;
		string name = String.Empty;
		
		Identifier();

#line  1233 "VBNET.ATG" 
		name = t.val; 
		if (la.kind == 49) {
			lexer.NextToken();
			TypeName(
#line  1234 "VBNET.ATG" 
out type);
		}
		Expect(11);
		Expr(
#line  1235 "VBNET.ATG" 
out expr);

#line  1237 "VBNET.ATG" 
		VariableDeclaration f = new VariableDeclaration(name, expr);
		f.Type = type;
		constantDeclaration.Add(f);
		
	}

	void AccessorDecls(
#line  1170 "VBNET.ATG" 
out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {

#line  1172 "VBNET.ATG" 
		ArrayList attributes = new ArrayList(); 
		AttributeSection section;
		getBlock = null;
		setBlock = null; 
		
		while (la.kind == 28) {
			AttributeSection(
#line  1177 "VBNET.ATG" 
out section);

#line  1177 "VBNET.ATG" 
			attributes.Add(section); 
		}
		if (la.kind == 102) {
			GetAccessorDecl(
#line  1179 "VBNET.ATG" 
out getBlock, attributes);
			if (la.kind == 28 || la.kind == 158) {

#line  1181 "VBNET.ATG" 
				attributes = new ArrayList(); 
				while (la.kind == 28) {
					AttributeSection(
#line  1182 "VBNET.ATG" 
out section);

#line  1182 "VBNET.ATG" 
					attributes.Add(section); 
				}
				SetAccessorDecl(
#line  1183 "VBNET.ATG" 
out setBlock, attributes);
			}
		} else if (la.kind == 158) {
			SetAccessorDecl(
#line  1186 "VBNET.ATG" 
out setBlock, attributes);
			if (la.kind == 28 || la.kind == 102) {

#line  1188 "VBNET.ATG" 
				attributes = new ArrayList(); 
				while (la.kind == 28) {
					AttributeSection(
#line  1189 "VBNET.ATG" 
out section);

#line  1189 "VBNET.ATG" 
					attributes.Add(section); 
				}
				GetAccessorDecl(
#line  1190 "VBNET.ATG" 
out getBlock, attributes);
			}
		} else SynErr(212);
	}

	void GetAccessorDecl(
#line  1196 "VBNET.ATG" 
out PropertyGetRegion getBlock, ArrayList attributes) {

#line  1197 "VBNET.ATG" 
		Statement stmt = null; 
		Expect(102);
		Expect(1);
		Block(
#line  1200 "VBNET.ATG" 
out stmt);

#line  1202 "VBNET.ATG" 
		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes);
		
		Expect(89);
		Expect(102);
		Expect(1);
	}

	void SetAccessorDecl(
#line  1209 "VBNET.ATG" 
out PropertySetRegion setBlock, ArrayList attributes) {

#line  1211 "VBNET.ATG" 
		Statement stmt = null;
		ArrayList p = null;
		
		Expect(158);
		if (la.kind == 25) {
			lexer.NextToken();
			if (StartOf(4)) {
				FormalParameterList(
#line  1215 "VBNET.ATG" 
out p);
			}
			Expect(26);
		}
		Expect(1);
		Block(
#line  1217 "VBNET.ATG" 
out stmt);

#line  1219 "VBNET.ATG" 
		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
		setBlock.Parameters = p;
		
		Expect(89);
		Expect(158);
		Expect(1);
	}

	void ArrayNameModifier(
#line  1758 "VBNET.ATG" 
out ArrayList arrayModifiers) {

#line  1760 "VBNET.ATG" 
		arrayModifiers = null;
		
		ArrayTypeModifiers(
#line  1762 "VBNET.ATG" 
out arrayModifiers);
	}

	void ArrayInitializationModifier(
#line  1295 "VBNET.ATG" 
out ArrayList arrayModifiers) {

#line  1297 "VBNET.ATG" 
		arrayModifiers = null;
		
		Expect(25);
		InitializationRankList(
#line  1299 "VBNET.ATG" 
out arrayModifiers);
		Expect(26);
	}

	void ObjectCreateExpression(
#line  1669 "VBNET.ATG" 
out Expression oce) {

#line  1671 "VBNET.ATG" 
		TypeReference type = null;
		Expression initializer = null;
		ArrayList arguments = null;
		oce = null;
		
		Expect(128);
		TypeNameWithoutRank(
#line  1676 "VBNET.ATG" 
out type);
		if (la.kind == 25) {
			lexer.NextToken();
			if (StartOf(17)) {
				ArgumentList(
#line  1678 "VBNET.ATG" 
out arguments);
			}
			Expect(26);
		}
		if (la.kind == 21) {
			ArrayInitializer(
#line  1682 "VBNET.ATG" 
out initializer);
		}

#line  1685 "VBNET.ATG" 
		if(initializer == null) {
		oce = new ObjectCreateExpression(type, arguments);
		} else {
			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer as ArrayInitializerExpression);
			ace.Parameters = arguments;
			oce = ace;
		}
		
	}

	void VariableInitializer(
#line  1315 "VBNET.ATG" 
out Expression initializerExpression) {

#line  1317 "VBNET.ATG" 
		initializerExpression = null;
		
		if (StartOf(18)) {
			Expr(
#line  1319 "VBNET.ATG" 
out initializerExpression);
		} else if (la.kind == 21) {
			ArrayInitializer(
#line  1320 "VBNET.ATG" 
out initializerExpression);
		} else SynErr(213);
	}

	void InitializationRankList(
#line  1303 "VBNET.ATG" 
out ArrayList rank) {

#line  1305 "VBNET.ATG" 
		rank = null;
		Expression expr = null;
		
		Expr(
#line  1308 "VBNET.ATG" 
out expr);

#line  1308 "VBNET.ATG" 
		rank = new ArrayList(); rank.Add(expr); 
		while (la.kind == 12) {
			lexer.NextToken();
			Expr(
#line  1310 "VBNET.ATG" 
out expr);

#line  1310 "VBNET.ATG" 
			rank.Add(expr); 
		}
	}

	void ArrayInitializer(
#line  1324 "VBNET.ATG" 
out Expression outExpr) {

#line  1326 "VBNET.ATG" 
		Expression expr = null;
		ArrayInitializerExpression initializer = new ArrayInitializerExpression();
		
		Expect(21);
		if (StartOf(19)) {
			VariableInitializer(
#line  1331 "VBNET.ATG" 
out expr);

#line  1333 "VBNET.ATG" 
			initializer.CreateExpressions.Add(expr);
			
			while (
#line  1336 "VBNET.ATG" 
NotFinalComma()) {
				Expect(12);
				VariableInitializer(
#line  1336 "VBNET.ATG" 
out expr);

#line  1337 "VBNET.ATG" 
				initializer.CreateExpressions.Add(expr); 
			}
		}
		Expect(22);

#line  1340 "VBNET.ATG" 
		outExpr = initializer; 
	}

	void EventMemberSpecifier(
#line  1403 "VBNET.ATG" 
out string name) {

#line  1404 "VBNET.ATG" 
		string type; name = String.Empty; 
		if (StartOf(9)) {
			Identifier();

#line  1405 "VBNET.ATG" 
			type = t.val; 
			Expect(10);
			Identifier();

#line  1407 "VBNET.ATG" 
			name = type + "." + t.val; 
		} else if (la.kind == 125) {
			lexer.NextToken();
			Expect(10);
			if (StartOf(9)) {
				Identifier();

#line  1410 "VBNET.ATG" 
				name = "MyBase." + t.val; 
			} else if (la.kind == 93) {
				lexer.NextToken();

#line  1411 "VBNET.ATG" 
				name = "MyBase.Error"; 
			} else SynErr(214);
		} else SynErr(215);
	}

	void ConditionalOrExpr(
#line  1549 "VBNET.ATG" 
out Expression outExpr) {

#line  1550 "VBNET.ATG" 
		Expression expr; 
		ConditionalAndExpr(
#line  1551 "VBNET.ATG" 
out outExpr);
		while (la.kind == 140) {
			lexer.NextToken();
			ConditionalAndExpr(
#line  1551 "VBNET.ATG" 
out expr);

#line  1551 "VBNET.ATG" 
			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BooleanOr, expr);  
		}
	}

	void AssignmentOperator(
#line  1446 "VBNET.ATG" 
out AssignmentOperatorType op) {

#line  1447 "VBNET.ATG" 
		op = AssignmentOperatorType.None; 
		switch (la.kind) {
		case 11: {
			lexer.NextToken();

#line  1448 "VBNET.ATG" 
			op = AssignmentOperatorType.Assign; 
			break;
		}
		case 42: {
			lexer.NextToken();

#line  1449 "VBNET.ATG" 
			op = AssignmentOperatorType.ConcatString; 
			break;
		}
		case 34: {
			lexer.NextToken();

#line  1450 "VBNET.ATG" 
			op = AssignmentOperatorType.Add; 
			break;
		}
		case 36: {
			lexer.NextToken();

#line  1451 "VBNET.ATG" 
			op = AssignmentOperatorType.Subtract; 
			break;
		}
		case 37: {
			lexer.NextToken();

#line  1452 "VBNET.ATG" 
			op = AssignmentOperatorType.Multiply; 
			break;
		}
		case 38: {
			lexer.NextToken();

#line  1453 "VBNET.ATG" 
			op = AssignmentOperatorType.Divide; 
			break;
		}
		case 39: {
			lexer.NextToken();

#line  1454 "VBNET.ATG" 
			op = AssignmentOperatorType.DivideInteger; 
			break;
		}
		case 35: {
			lexer.NextToken();

#line  1455 "VBNET.ATG" 
			op = AssignmentOperatorType.Power; 
			break;
		}
		case 40: {
			lexer.NextToken();

#line  1456 "VBNET.ATG" 
			op = AssignmentOperatorType.ShiftLeft; 
			break;
		}
		case 41: {
			lexer.NextToken();

#line  1457 "VBNET.ATG" 
			op = AssignmentOperatorType.ShiftRight; 
			break;
		}
		default: SynErr(216); break;
		}
	}

	void UnaryExpr(
#line  1425 "VBNET.ATG" 
out Expression uExpr) {

#line  1427 "VBNET.ATG" 
		Expression expr;
		UnaryOperatorType uop = UnaryOperatorType.None;
		bool isUOp = false;
		
		while (la.kind == 14 || la.kind == 15 || la.kind == 16) {
			if (la.kind == 14) {
				lexer.NextToken();

#line  1431 "VBNET.ATG" 
				uop = UnaryOperatorType.Plus; isUOp = true; 
			} else if (la.kind == 15) {
				lexer.NextToken();

#line  1432 "VBNET.ATG" 
				uop = UnaryOperatorType.Minus; isUOp = true; 
			} else {
				lexer.NextToken();

#line  1434 "VBNET.ATG" 
				uop = UnaryOperatorType.Star;  isUOp = true;
			}
		}
		SimpleExpr(
#line  1436 "VBNET.ATG" 
out expr);

#line  1438 "VBNET.ATG" 
		if (isUOp) {
		uExpr = new UnaryOperatorExpression(expr, uop);
		} else {
			uExpr = expr;
		}
		
	}

	void SimpleExpr(
#line  1461 "VBNET.ATG" 
out Expression pexpr) {

#line  1463 "VBNET.ATG" 
		Expression expr;
		TypeReference type = null;
		string name = String.Empty;
		pexpr = null;
		
		if (StartOf(20)) {
			switch (la.kind) {
			case 3: {
				lexer.NextToken();

#line  1471 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 4: {
				lexer.NextToken();

#line  1472 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 7: {
				lexer.NextToken();

#line  1473 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 6: {
				lexer.NextToken();

#line  1474 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 5: {
				lexer.NextToken();

#line  1475 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 9: {
				lexer.NextToken();

#line  1476 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 8: {
				lexer.NextToken();

#line  1477 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(t.literalValue, t.val);  
				break;
			}
			case 175: {
				lexer.NextToken();

#line  1479 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(true, "true");  
				break;
			}
			case 97: {
				lexer.NextToken();

#line  1480 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(false, "false"); 
				break;
			}
			case 131: {
				lexer.NextToken();

#line  1481 "VBNET.ATG" 
				pexpr = new PrimitiveExpression(null, "null");  
				break;
			}
			case 25: {
				lexer.NextToken();
				Expr(
#line  1482 "VBNET.ATG" 
out expr);
				Expect(26);

#line  1482 "VBNET.ATG" 
				pexpr = new ParenthesizedExpression(expr); 
				break;
			}
			case 2: case 52: case 71: case 171: {
				Identifier();

#line  1483 "VBNET.ATG" 
				pexpr = new IdentifierExpression(t.val); 
				break;
			}
			case 53: case 55: case 66: case 77: case 78: case 85: case 112: case 118: case 161: case 162: case 167: {

#line  1484 "VBNET.ATG" 
				string val = String.Empty; 
				PrimitiveTypeName(
#line  1484 "VBNET.ATG" 
out val);
				Expect(10);
				Identifier();

#line  1485 "VBNET.ATG" 
				pexpr = new FieldReferenceOrInvocationExpression(new TypeReferenceExpression(val), t.val); 
				break;
			}
			case 120: {
				lexer.NextToken();

#line  1486 "VBNET.ATG" 
				pexpr = new ThisReferenceExpression(); 
				break;
			}
			case 125: case 126: {

#line  1487 "VBNET.ATG" 
				Expression retExpr = null; 
				if (la.kind == 125) {
					lexer.NextToken();

#line  1488 "VBNET.ATG" 
					retExpr = new BaseReferenceExpression(); 
				} else if (la.kind == 126) {
					lexer.NextToken();

#line  1489 "VBNET.ATG" 
					retExpr = new ClassReferenceExpression(); 
				} else SynErr(217);
				Expect(10);
				IdentifierOrKeyword(
#line  1491 "VBNET.ATG" 
out name);

#line  1491 "VBNET.ATG" 
				pexpr = new FieldReferenceOrInvocationExpression(retExpr, name); 
				break;
			}
			case 128: {
				ObjectCreateExpression(
#line  1492 "VBNET.ATG" 
out expr);

#line  1492 "VBNET.ATG" 
				pexpr = expr; 
				break;
			}
			case 76: case 83: {
				if (la.kind == 83) {
					lexer.NextToken();
				} else if (la.kind == 76) {
					lexer.NextToken();
				} else SynErr(218);
				Expect(25)