parser.cs

c#源代码

#line  1378 "VBNET.ATG" 
			charsetModifier = CharsetModifier.Auto; 
		} else if (la.kind == 178) {
			lexer.NextToken();

#line  1379 "VBNET.ATG" 
			charsetModifier = CharsetModifier.Unicode; 
		} else SynErr(210);
	}

	void VariableDeclarator(
#line  1276 "VBNET.ATG" 
ArrayList fieldDeclaration) {

#line  1278 "VBNET.ATG" 
		Expression expr = null;
		TypeReference type = null;
		ObjectCreateExpression oce = null;
		ArrayCreateExpression ace = null;
		ArrayList rank = null;
		ArrayList dimension = null;
		
		Identifier();

#line  1287 "VBNET.ATG" 
		VariableDeclaration f = new VariableDeclaration(t.val);
		
		if (
#line  1289 "VBNET.ATG" 
IsRank()) {
			ArrayTypeModifiers(
#line  1289 "VBNET.ATG" 
out rank);
		}
		if (
#line  1290 "VBNET.ATG" 
IsSize()) {
			ArrayInitializationModifier(
#line  1290 "VBNET.ATG" 
out dimension);
		}
		if (
#line  1292 "VBNET.ATG" 
IsObjectCreation()) {
			Expect(49);
			ObjectCreateExpression(
#line  1292 "VBNET.ATG" 
out expr);

#line  1294 "VBNET.ATG" 
			if(expr is ArrayCreateExpression) {
			ace = expr as ArrayCreateExpression;
			f.Initializer = ace.ArrayInitializer;
			
			} else {
				oce = expr as ObjectCreateExpression;
				f.Initializer = oce;
				if(oce.CreateType != null) {
					f.Type = oce.CreateType;
				}
			}
			
		} else if (StartOf(16)) {
			if (la.kind == 49) {
				lexer.NextToken();
				TypeName(
#line  1307 "VBNET.ATG" 
out type);
			}

#line  1309 "VBNET.ATG" 
			if(type != null) {
			type.Dimension = dimension;
			}
			f.Type = type;
			if (type != null && rank != null) {
				if(type.RankSpecifier != null) {
					Error("array rank only allowed one time");
				} else {
					type.RankSpecifier = rank;
				}
			}
			
			if (la.kind == 11) {
				lexer.NextToken();
				VariableInitializer(
#line  1321 "VBNET.ATG" 
out expr);

#line  1321 "VBNET.ATG" 
				f.Initializer = expr; 
			}
		} else SynErr(211);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void ArrayTypeModifiers(
#line  1813 "VBNET.ATG" 
out ArrayList arrayModifiers) {

#line  1815 "VBNET.ATG" 
		arrayModifiers = new ArrayList();
		int i = 0;
		
		while (
#line  1818 "VBNET.ATG" 
IsRank()) {
			Expect(25);
			if (la.kind == 12 || la.kind == 26) {
				RankList(
#line  1820 "VBNET.ATG" 
out i);
			}

#line  1822 "VBNET.ATG" 
			arrayModifiers.Add(i);
			
			Expect(26);
		}

#line  1827 "VBNET.ATG" 
		if(arrayModifiers.Count == 0) {
		 arrayModifiers = null;
		}
		
	}

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

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

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

#line  1703 "VBNET.ATG" 
		TypeReference type = null;
		Expression initializer = null;
		ArrayList arguments = null;
		oce = null;
		
		Expect(128);
		ArrayTypeName(
#line  1708 "VBNET.ATG" 
out type);
		if (la.kind == 25) {
			lexer.NextToken();
			if (StartOf(17)) {
				ArgumentList(
#line  1710 "VBNET.ATG" 
out arguments);
			}
			Expect(26);
		}
		if (la.kind == 21) {
			ArrayInitializer(
#line  1714 "VBNET.ATG" 
out initializer);
		}

#line  1717 "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  1347 "VBNET.ATG" 
out Expression initializerExpression) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#line  1459 "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  1463 "VBNET.ATG" 
				uop = UnaryOperatorType.Plus; isUOp = true; 
			} else if (la.kind == 15) {
				lexer.NextToken();

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

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

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

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

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

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

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

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

#line  1506 "VBNET.ATG"