public CatchClause(TypeReference type, string variableName, Statement statementBlock, Expression condition)
{
this.type = type;
this.variableName = variableName;
this.statementBlock = statementBlock;
this.condition = condition;
}
public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition)
{
this.condition = condition;
this.embeddedStatement = embeddedStatement;
this.conditionType = conditionType;
this.conditionPosition = conditionPosition;
}
public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParamModifiers paramModifiers, Expression defaultValue)
{
this.typeReference = typeReference;
this.parameterName = parameterName;
this.paramModifiers = paramModifiers;
this.attributes = attributes;
this.defaultValue = defaultValue;
}
public ForStatement(LoopControlVariableExpression loopControlVariable, Expression start, Expression end, Expression step, Statement embeddedStatement, ArrayList nextExpressions)
{
this.start = start;
this.nextExpressions = nextExpressions;
this.end = end;
this.step = step;
this.embeddedStatement = embeddedStatement;
this.loopControlVariable = loopControlVariable;
}
public VariableDeclaration(string name, Expression initializer)
{
this.name = name;
this.initializer = initializer;
}
public ParenthesizedExpression(Expression expression)
{
this.expression = expression;
}
void MultiplicativeExpr(
#line 1683 "VBNET.ATG"
out Expression outExpr) {
#line 1685 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
UnaryExpr(
#line 1688 "VBNET.ATG"
out outExpr);
while (StartOf(24)) {
if (la.kind == 16) {
lexer.NextToken();
#line 1691 "VBNET.ATG"
op = BinaryOperatorType.Multiply;
} else if (la.kind == 17) {
lexer.NextToken();
#line 1692 "VBNET.ATG"
op = BinaryOperatorType.Divide;
} else if (la.kind == 18) {
lexer.NextToken();
#line 1693 "VBNET.ATG"
op = BinaryOperatorType.DivideInteger;
} else if (la.kind == 121) {
lexer.NextToken();
#line 1694 "VBNET.ATG"
op = BinaryOperatorType.Modulus;
} else {
lexer.NextToken();
#line 1695 "VBNET.ATG"
op = BinaryOperatorType.Power;
}
UnaryExpr(
#line 1697 "VBNET.ATG"
out expr);
#line 1697 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void ShiftExpr(
#line 1652 "VBNET.ATG"
out Expression outExpr) {
#line 1654 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
AdditiveExpr(
#line 1657 "VBNET.ATG"
out outExpr);
while (la.kind == 32 || la.kind == 33) {
if (la.kind == 32) {
lexer.NextToken();
#line 1660 "VBNET.ATG"
op = BinaryOperatorType.ShiftLeft;
} else {
lexer.NextToken();
#line 1661 "VBNET.ATG"
op = BinaryOperatorType.ShiftRight;
}
AdditiveExpr(
#line 1663 "VBNET.ATG"
out expr);
#line 1663 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void EqualityExpr(
#line 1615 "VBNET.ATG"
out Expression outExpr) {
#line 1617 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
RelationalExpr(
#line 1620 "VBNET.ATG"
out outExpr);
while (la.kind == 11 || la.kind == 29 || la.kind == 117) {
if (la.kind == 29) {
lexer.NextToken();
#line 1623 "VBNET.ATG"
op = BinaryOperatorType.InEquality;
} else if (la.kind == 11) {
lexer.NextToken();
#line 1624 "VBNET.ATG"
op = BinaryOperatorType.Equality;
} else {
lexer.NextToken();
#line 1625 "VBNET.ATG"
op = BinaryOperatorType.Like;
}
RelationalExpr(
#line 1627 "VBNET.ATG"
out expr);
#line 1627 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
void AndExpr(
#line 1601 "VBNET.ATG"
out Expression outExpr) {
#line 1602 "VBNET.ATG"
Expression expr;
NotExpr(
#line 1603 "VBNET.ATG"
out outExpr);
while (la.kind == 46) {
lexer.NextToken();
NotExpr(
#line 1603 "VBNET.ATG"
out expr);
#line 1603 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseAnd, expr);
}
}
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 Expr(
#line 1447 "VBNET.ATG"
out Expression expr) {
#line 1448 "VBNET.ATG"
expr = new Expression();
ConditionalOrExpr(
#line 1449 "VBNET.ATG"
out expr);
while (StartOf(14)) {
#line 1452 "VBNET.ATG"
AssignmentOperatorType op; Expression val;
AssignmentOperator(
#line 1453 "VBNET.ATG"
out op);
Expr(
#line 1453 "VBNET.ATG"
out val);
#line 1453 "VBNET.ATG"
expr = new AssignmentExpression(expr, op, val);
}
}
public WithStatement(Expression withExpression)
{
this.withExpression = withExpression;
}
public NamedArgumentExpression(string parametername, Expression expression)
{
this.parametername = parametername;
this.expression = expression;
}
public LockStatement(Expression lockExpression, Statement embeddedStatement)
{
this.lockExpression = lockExpression;
this.embeddedStatement = embeddedStatement;
}
void InclusiveOrExpr(
#line 1591 "VBNET.ATG"
out Expression outExpr) {
#line 1592 "VBNET.ATG"
Expression expr;
ExclusiveOrExpr(
#line 1593 "VBNET.ATG"
out outExpr);
while (la.kind == 187) {
lexer.NextToken();
ExclusiveOrExpr(
#line 1593 "VBNET.ATG"
out expr);
#line 1593 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.ExclusiveOr, expr);
}
}
void ExclusiveOrExpr(
#line 1596 "VBNET.ATG"
out Expression outExpr) {
#line 1597 "VBNET.ATG"
Expression expr;
AndExpr(
#line 1598 "VBNET.ATG"
out outExpr);
while (la.kind == 139) {
lexer.NextToken();
AndExpr(
#line 1598 "VBNET.ATG"
out expr);
#line 1598 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BitwiseOr, expr);
}
}
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 NotExpr(
#line 1606 "VBNET.ATG"
out Expression outExpr) {
#line 1607 "VBNET.ATG"
UnaryOperatorType uop = UnaryOperatorType.None;
while (la.kind == 130) {
lexer.NextToken();
#line 1608 "VBNET.ATG"
uop = UnaryOperatorType.Not;
}
EqualityExpr(
#line 1609 "VBNET.ATG"
out outExpr);
#line 1610 "VBNET.ATG"
if (uop != UnaryOperatorType.None)
outExpr = new UnaryOperatorExpression(outExpr, uop);
}
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 RelationalExpr(
#line 1631 "VBNET.ATG"
out Expression outExpr) {
#line 1633 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
ShiftExpr(
#line 1636 "VBNET.ATG"
out outExpr);
while (StartOf(22)) {
if (StartOf(23)) {
if (la.kind == 28) {
lexer.NextToken();
#line 1639 "VBNET.ATG"
op = BinaryOperatorType.LessThan;
} else if (la.kind == 27) {
lexer.NextToken();
#line 1640 "VBNET.ATG"
op = BinaryOperatorType.GreaterThan;
} else if (la.kind == 31) {
lexer.NextToken();
#line 1641 "VBNET.ATG"
op = BinaryOperatorType.LessThanOrEqual;
} else if (la.kind == 30) {
lexer.NextToken();
#line 1642 "VBNET.ATG"
op = BinaryOperatorType.GreaterThanOrEqual;
} else SynErr(223);
ShiftExpr(
#line 1644 "VBNET.ATG"
out expr);
#line 1644 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
} else {
lexer.NextToken();
#line 1647 "VBNET.ATG"
op = BinaryOperatorType.IS;
Expr(
#line 1648 "VBNET.ATG"
out expr);
#line 1648 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
}
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 AdditiveExpr(
#line 1667 "VBNET.ATG"
out Expression outExpr) {
#line 1669 "VBNET.ATG"
Expression expr;
BinaryOperatorType op = BinaryOperatorType.None;
MultiplicativeExpr(
#line 1672 "VBNET.ATG"
out outExpr);
while (la.kind == 14 || la.kind == 15 || la.kind == 19) {
if (la.kind == 14) {
lexer.NextToken();
#line 1675 "VBNET.ATG"
op = BinaryOperatorType.Add;
} else if (la.kind == 15) {
lexer.NextToken();
#line 1676 "VBNET.ATG"
op = BinaryOperatorType.Subtract;
} else {
lexer.NextToken();
#line 1677 "VBNET.ATG"
op = BinaryOperatorType.Concat;
}
MultiplicativeExpr(
#line 1679 "VBNET.ATG"
out expr);
#line 1679 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, op, expr);
}
}
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;
}
}
public BinaryOperatorExpression(Expression left, BinaryOperatorType op, Expression right)
{
this.left = left;
this.op = op;
this.right = right;
}
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"
pexpr = new PrimitiveExpression(t.literalValue, t.val);
break;
}
case 5: {
lexer.NextToken();
#line 1507 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val);
break;
}
case 9: {
lexer.NextToken();
#line 1508 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val);
break;
}
case 8: {
lexer.NextToken();
#line 1509 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val);
break;
}
case 175: {
lexer.NextToken();
#line 1511 "VBNET.ATG"
pexpr = new PrimitiveExpression(true, "true");
break;
}
case 97: {
lexer.NextToken();
#line 1512 "VBNET.ATG"
pexpr = new PrimitiveExpression(false, "false");
break;
}
case 131: {
lexer.NextToken();
#line 1513 "VBNET.ATG"
pexpr = new PrimitiveExpression(null, "null");
break;
}
case 25: {
lexer.NextToken();
Expr(
#line 1514 "VBNET.ATG"
out expr);
Expect(26);
#line 1514 "VBNET.ATG"
pexpr = new ParenthesizedExpression(expr);
break;
}
case 2: case 52: case 71: case 171: {
Identifier();
#line 1515 "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 1516 "VBNET.ATG"
string val = String.Empty;
PrimitiveTypeName(
#line 1516 "VBNET.ATG"
out val);
Expect(10);
Identifier();
#line 1517 "VBNET.ATG"
pexpr = new FieldReferenceOrInvocationExpression(new TypeReferenceExpression(val), t.val);
break;
}
case 120: {
lexer.NextToken();
#line 1518 "VBNET.ATG"
pexpr = new ThisReferenceExpression();
break;
}
case 125: case 126: {
#line 1519 "VBNET.ATG"
Expression retExpr = null;
if (la.kind == 125) {
lexer.NextToken();
#line 1520 "VBNET.ATG"
retExpr = new BaseReferenceExpression();
} else if (la.kind == 126) {
lexer.NextToken();
#line 1521 "VBNET.ATG"
retExpr = new ClassReferenceExpression();
} else SynErr(217);
Expect(10);
IdentifierOrKeyword(
#line 1523 "VBNET.ATG"
out name);
#line 1523 "VBNET.ATG"
pexpr = new FieldReferenceOrInvocationExpression(retExpr, name);
break;
}
case 128: {
ObjectCreateExpression(
#line 1524 "VBNET.ATG"
out expr);
#line 1524 "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);
Expr(
#line 1525 "VBNET.ATG"
out expr);
Expect(12);
TypeName(
#line 1525 "VBNET.ATG"
out type);
Expect(26);
#line 1525 "VBNET.ATG"
pexpr = new CastExpression(type, expr);
break;
}
case 60: case 61: case 62: case 63: case 64: case 65: case 67: case 69: case 70: case 73: case 74: case 75: {
CastTarget(
#line 1526 "VBNET.ATG"
out type);
Expect(25);
Expr(
#line 1526 "VBNET.ATG"
out expr);
Expect(26);
#line 1526 "VBNET.ATG"
pexpr = new CastExpression(type, expr, true);
break;
}
case 44: {
lexer.NextToken();
Expr(
#line 1527 "VBNET.ATG"
out expr);
#line 1527 "VBNET.ATG"
pexpr = new AddressOfExpression(expr);
break;
}
case 103: {
lexer.NextToken();
Expect(25);
TypeName(
#line 1528 "VBNET.ATG"
out type);
Expect(26);
#line 1528 "VBNET.ATG"
pexpr = new GetTypeExpression(type);
break;
}
case 177: {
lexer.NextToken();
SimpleExpr(
#line 1529 "VBNET.ATG"
out expr);
Expect(114);
TypeName(
#line 1529 "VBNET.ATG"
out type);
#line 1529 "VBNET.ATG"
pexpr = new TypeOfExpression(expr, type);
break;
}
}
while (la.kind == 10 || la.kind == 25) {
if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
#line 1532 "VBNET.ATG"
out name);
#line 1532 "VBNET.ATG"
pexpr = new FieldReferenceOrInvocationExpression(pexpr, name);
} else {
lexer.NextToken();
#line 1533 "VBNET.ATG"
ArrayList parameters = new ArrayList();
if (StartOf(21)) {
#line 1535 "VBNET.ATG"
expr = null;
if (StartOf(18)) {
Argument(
#line 1535 "VBNET.ATG"
out expr);
}
#line 1535 "VBNET.ATG"
parameters.Add(expr);
while (la.kind == 12) {
lexer.NextToken();
#line 1537 "VBNET.ATG"
expr = null;
if (StartOf(18)) {
Argument(
#line 1538 "VBNET.ATG"
out expr);
}
#line 1538 "VBNET.ATG"
parameters.Add(expr);
}
}
Expect(26);
#line 1541 "VBNET.ATG"
pexpr = new InvocationExpression(pexpr, parameters);
}
}
} else if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
#line 1545 "VBNET.ATG"
out name);
#line 1545 "VBNET.ATG"
pexpr = new FieldReferenceOrInvocationExpression(pexpr, name);
while (la.kind == 10 || la.kind == 25) {
if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
#line 1547 "VBNET.ATG"
out name);
#line 1547 "VBNET.ATG"
pexpr = new FieldReferenceOrInvocationExpression(pexpr, name);
} else {
lexer.NextToken();
#line 1548 "VBNET.ATG"
ArrayList parameters = new ArrayList();
if (StartOf(21)) {
#line 1550 "VBNET.ATG"
expr = null;
if (StartOf(18)) {
Argument(
#line 1550 "VBNET.ATG"
out expr);
}
#line 1550 "VBNET.ATG"
parameters.Add(expr);
while (la.kind == 12) {
lexer.NextToken();
#line 1552 "VBNET.ATG"
expr = null;
if (StartOf(18)) {
Argument(
#line 1553 "VBNET.ATG"
out expr);
}
#line 1553 "VBNET.ATG"
parameters.Add(expr);
}
}
Expect(26);
#line 1556 "VBNET.ATG"
pexpr = new InvocationExpression(pexpr, parameters);
}
}
} else SynErr(219);
}
public ReturnStatement(Expression returnExpression)
{
this.returnExpression = returnExpression;
}
void Argument(
#line 1743 "VBNET.ATG"
out Expression argumentexpr) {
#line 1745 "VBNET.ATG"
Expression expr;
argumentexpr = null;
string name;
if (
#line 1749 "VBNET.ATG"
IsNamedAssign()) {
Identifier();
#line 1749 "VBNET.ATG"
name = t.val;
Expect(13);
Expect(11);
Expr(
#line 1749 "VBNET.ATG"
out expr);
#line 1751 "VBNET.ATG"
argumentexpr = new NamedArgumentExpression(name, expr);
} else if (StartOf(18)) {
Expr(
#line 1754 "VBNET.ATG"
out argumentexpr);
} else SynErr(222);
}
public AddressOfExpression(Expression Procedure)
{
this.Procedure = Procedure;
}
void ConditionalAndExpr(
#line 1586 "VBNET.ATG"
out Expression outExpr) {
#line 1587 "VBNET.ATG"
Expression expr;
InclusiveOrExpr(
#line 1588 "VBNET.ATG"
out outExpr);
while (la.kind == 47) {
lexer.NextToken();
InclusiveOrExpr(
#line 1588 "VBNET.ATG"
out expr);
#line 1588 "VBNET.ATG"
outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.BooleanAnd, expr);
}
}
