public override object Visit(OperatorDeclaration operatorDeclaration, object data)
 {
     return null;
 }
 public override object Visit(OperatorDeclaration operatorDeclaration, object data)
 {
     errors.Error(-1, -1, String.Format("Operator overloading cannot be performed"));
     return null;
 }
 public override object Visit(OperatorDeclaration operatorDeclaration, object data)
 {
     Console.WriteLine(operatorDeclaration.ToString());
     return operatorDeclaration.AcceptChildren(this, data);
 }
 public virtual object Visit(OperatorDeclaration operatorDeclaration, object data)
 {
     foreach (AttributeSection section in operatorDeclaration.Attributes) {
         section.AcceptVisitor(this, data);
     }
     blockStack.Push(operatorDeclaration.Body);
     object ret = data;
     if (operatorDeclaration.Body != null) {
         ret = operatorDeclaration.Body.AcceptChildren(this, data);
     }
     blockStack.Pop();
     return ret;
 }
示例#5
0
	void StructMemberDecl(
#line  1005 "cs.ATG" 
Modifiers m, ArrayList attributes) {

#line  1007 "cs.ATG" 
		string qualident = null;
		TypeReference type;
		Expression expr;
		ArrayList p = new ArrayList();
		Statement stmt = null;
		ArrayList variableDeclarators = new ArrayList();
		
		if (la.kind == 59) {

#line  1015 "cs.ATG" 
			m.Check(Modifier.Constants); 
			lexer.NextToken();
			Type(
#line  1017 "cs.ATG" 
out type);
			Expect(1);

#line  1017 "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  1021 "cs.ATG" 
out expr);

#line  1021 "cs.ATG" 
			f.Initializer = expr; 
			while (la.kind == 12) {
				lexer.NextToken();
				Expect(1);

#line  1022 "cs.ATG" 
				f = new VariableDeclaration(t.val);
				fd.Fields.Add(f);
				
				Expect(3);
				Expr(
#line  1025 "cs.ATG" 
out expr);

#line  1025 "cs.ATG" 
				f.Initializer = expr; 
			}
			Expect(10);

#line  1026 "cs.ATG" 
			fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); 
		} else if (
#line  1029 "cs.ATG" 
NotVoidPointer()) {

#line  1029 "cs.ATG" 
			m.Check(Modifier.PropertysEventsMethods); 
			Expect(122);

#line  1030 "cs.ATG" 
			Point startPos = t.Location; 
			Qualident(
#line  1031 "cs.ATG" 
out qualident);
			Expect(18);
			if (StartOf(9)) {
				FormalParameterList(
#line  1032 "cs.ATG" 
out p);
			}
			Expect(19);

#line  1032 "cs.ATG" 
			MethodDeclaration methodDeclaration = new MethodDeclaration(qualident, 
			                                                           m.Modifier, 
			                                                           new TypeReference("void"), 
			                                                           p, 
			                                                           attributes);
			methodDeclaration.StartLocation = startPos;
			methodDeclaration.EndLocation   = t.EndLocation;
			compilationUnit.AddChild(methodDeclaration);
			compilationUnit.BlockStart(methodDeclaration);
			
			if (la.kind == 14) {
				Block(
#line  1042 "cs.ATG" 
out stmt);
			} else if (la.kind == 10) {
				lexer.NextToken();
			} else SynErr(141);

#line  1042 "cs.ATG" 
			compilationUnit.BlockEnd();
			methodDeclaration.Body  = (BlockStatement)stmt;
			
		} else if (la.kind == 68) {

#line  1046 "cs.ATG" 
			m.Check(Modifier.PropertysEventsMethods); 
			lexer.NextToken();

#line  1047 "cs.ATG" 
			EventDeclaration eventDecl = new EventDeclaration(m.Modifier, attributes);
			eventDecl.StartLocation = t.Location;
			compilationUnit.AddChild(eventDecl);
			compilationUnit.BlockStart(eventDecl);
			EventAddRegion addBlock = null;
			EventRemoveRegion removeBlock = null;
			
			Type(
#line  1054 "cs.ATG" 
out type);

#line  1054 "cs.ATG" 
			eventDecl.TypeReference = type; 
			if (
#line  1056 "cs.ATG" 
IsVarDecl()) {
				VariableDeclarator(
#line  1056 "cs.ATG" 
variableDeclarators);
				while (la.kind == 12) {
					lexer.NextToken();
					VariableDeclarator(
#line  1057 "cs.ATG" 
variableDeclarators);
				}
				Expect(10);

#line  1057 "cs.ATG" 
				eventDecl.VariableDeclarators = variableDeclarators; eventDecl.EndLocation = t.EndLocation;  
			} else if (la.kind == 1) {
				Qualident(
#line  1058 "cs.ATG" 
out qualident);

#line  1058 "cs.ATG" 
				eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation;  
				Expect(14);

#line  1059 "cs.ATG" 
				eventDecl.BodyStart = t.Location; 
				EventAccessorDecls(
#line  1060 "cs.ATG" 
out addBlock, out removeBlock);
				Expect(15);

#line  1061 "cs.ATG" 
				eventDecl.BodyEnd   = t.EndLocation; 
			} else SynErr(142);

#line  1062 "cs.ATG" 
			compilationUnit.BlockEnd();
				                                           eventDecl.AddRegion = addBlock;
			eventDecl.RemoveRegion = removeBlock;
			
		} else if (
#line  1069 "cs.ATG" 
IdentAndLPar()) {

#line  1069 "cs.ATG" 
			m.Check(Modifier.Constructors | Modifier.StaticConstructors); 
			Expect(1);

#line  1070 "cs.ATG" 
			string name = t.val; Point startPos = t.Location; 
			Expect(18);
			if (StartOf(9)) {

#line  1070 "cs.ATG" 
				m.Check(Modifier.Constructors); 
				FormalParameterList(
#line  1071 "cs.ATG" 
out p);
			}
			Expect(19);

#line  1073 "cs.ATG" 
			ConstructorInitializer init = null;  
			if (la.kind == 9) {

#line  1074 "cs.ATG" 
				m.Check(Modifier.Constructors); 
				ConstructorInitializer(
#line  1075 "cs.ATG" 
out init);
			}

#line  1077 "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  1082 "cs.ATG" 
out stmt);
			} else if (la.kind == 10) {
				lexer.NextToken();
			} else SynErr(143);

#line  1082 "cs.ATG" 
			cd.Body = (BlockStatement)stmt; compilationUnit.AddChild(cd); 
		} else if (la.kind == 69 || la.kind == 79) {

#line  1085 "cs.ATG" 
			m.Check(Modifier.Operators);
			if (m.isNone) Error("at least one modifier must be set"); 
			bool isImplicit = true;
			
			if (la.kind == 79) {
				lexer.NextToken();
			} else {
				lexer.NextToken();

#line  1089 "cs.ATG" 
				isImplicit = false; 
			}
			Expect(91);
			Type(
#line  1090 "cs.ATG" 
out type);

#line  1090 "cs.ATG" 
			TypeReference operatorType = type; 
			Expect(18);
			Type(
#line  1091 "cs.ATG" 
out type);
			Expect(1);

#line  1091 "cs.ATG" 
			string varName = t.val; 
			Expect(19);
			if (la.kind == 14) {
				Block(
#line  1091 "cs.ATG" 
out stmt);
			} else if (la.kind == 10) {
				lexer.NextToken();

#line  1091 "cs.ATG" 
				stmt = null; 
			} else SynErr(144);

#line  1094 "cs.ATG" 
			OperatorDeclarator operatorDeclarator = new OperatorDeclarator(isImplicit ? OperatorType.Implicit : OperatorType.Explicit,
			                                                              operatorType,
			                                                              type,
			                                                              varName);
			OperatorDeclaration operatorDeclaration = new OperatorDeclaration(operatorDeclarator, m.Modifier, attributes);
			operatorDeclaration.Body = stmt;
			compilationUnit.AddChild(operatorDeclaration);
			
		} else if (StartOf(17)) {

#line  1104 "cs.ATG" 
			bool partial = false; 
			if (
#line  1105 "cs.ATG" 
IdentIsPartial ()) {
				lexer.NextToken();

#line  1105 "cs.ATG" 
				partial = true; 
			}
			TypeDecl(
#line  1106 "cs.ATG" 
m, attributes, partial);
		} else if (StartOf(8)) {
			Type(
#line  1107 "cs.ATG" 
out type);

#line  1107 "cs.ATG" 
			Point startPos = t.Location; 
			if (la.kind == 91) {

#line  1109 "cs.ATG" 
				Token op;
				m.Check(Modifier.Operators);
				if (m.isNone) Error("at least one modifier must be set");
				
				lexer.NextToken();
				OverloadableOperator(
#line  1113 "cs.ATG" 
out op);

#line  1113 "cs.ATG" 
				TypeReference firstType, secondType = null; string secondName = null; 
				Expect(18);
				Type(
#line  1114 "cs.ATG" 
out firstType);
				Expect(1);

#line  1114 "cs.ATG" 
				string firstName = t.val; 
				if (la.kind == 12) {
					lexer.NextToken();
					Type(
#line  1115 "cs.ATG" 
out secondType);
					Expect(1);

#line  1115 "cs.ATG" 
					secondName = t.val; 

#line  1115 "cs.ATG" 
					if (ParserUtil.IsUnaryOperator(op) && !ParserUtil.IsBinaryOperator(op))
					Error("too many operands for unary operator"); 
					
				} else if (la.kind == 19) {

#line  1118 "cs.ATG" 
					if (ParserUtil.IsBinaryOperator(op))
					Error("too few operands for binary operator");
					
				} else SynErr(145);
				Expect(19);
				if (la.kind == 14) {
					Block(
#line  1122 "cs.ATG" 
out stmt);
				} else if (la.kind == 10) {
					lexer.NextToken();
				} else SynErr(146);

#line  1124 "cs.ATG" 
				OperatorDeclarator operatorDeclarator = new OperatorDeclarator(secondType != null ? OperatorType.Binary : OperatorType.Unary, 
				                                                              type,
				                                                              op.kind,
				                                                              firstType,
				                                                              firstName,
				                                                              secondType,
				                                                              secondName);
				OperatorDeclaration operatorDeclaration = new OperatorDeclaration(operatorDeclarator, m.Modifier, attributes);
				operatorDeclaration.Body = stmt;
				compilationUnit.AddChild(operatorDeclaration);
				
			} else if (
#line  1137 "cs.ATG" 
IsVarDecl()) {

#line  1137 "cs.ATG" 
				m.Check(Modifier.Fields); 
				FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
				fd.StartLocation = startPos; 
				
				VariableDeclarator(
#line  1141 "cs.ATG" 
variableDeclarators);
				while (la.kind == 12) {
					lexer.NextToken();
					VariableDeclarator(
#line  1142 "cs.ATG" 
variableDeclarators);
				}
				Expect(10);

#line  1143 "cs.ATG" 
				fd.EndLocation = t.EndLocation; fd.Fields = variableDeclarators; compilationUnit.AddChild(fd); 
			} else if (la.kind == 110) {

#line  1146 "cs.ATG" 
				m.Check(Modifier.Indexers); 
				lexer.NextToken();
				Expect(16);
				FormalParameterList(
#line  1147 "cs.ATG" 
out p);
				Expect(17);

#line  1147 "cs.ATG" 
				Point endLocation = t.EndLocation; 
				Expect(14);

#line  1148 "cs.ATG" 
				IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
				indexer.StartLocation = startPos;
				indexer.EndLocation   = endLocation;
				indexer.BodyStart     = t.Location;
				PropertyGetRegion getRegion;
				PropertySetRegion setRegion;
				
				AccessorDecls(
#line  1155 "cs.ATG" 
out getRegion, out setRegion);
				Expect(15);

#line  1156 "cs.ATG" 
				indexer.BodyEnd    = t.EndLocation;
				indexer.GetRegion = getRegion;
				indexer.SetRegion = setRegion;
				compilationUnit.AddChild(indexer);
				
			} else if (la.kind == 1) {
				Qualident(
#line  1161 "cs.ATG" 
out qualident);

#line  1161 "cs.ATG" 
				Point qualIdentEndLocation = t.EndLocation; 
				if (la.kind == 14 || la.kind == 18) {
					if (la.kind == 18) {

#line  1164 "cs.ATG" 
						m.Check(Modifier.PropertysEventsMethods); 
						lexer.NextToken();
						if (StartOf(9)) {
							FormalParameterList(
#line  1165 "cs.ATG" 
out p);
						}
						Expect(19);

#line  1165 "cs.ATG" 
						MethodDeclaration methodDeclaration = new MethodDeclaration(qualident, 
						                                                     m.Modifier, 
						                                                     type, 
						                                                     p, 
						                                                     attributes);
						     methodDeclaration.StartLocation = startPos;
						     methodDeclaration.EndLocation   = t.EndLocation;
						     compilationUnit.AddChild(methodDeclaration);
						  
						if (la.kind == 14) {
							Block(
#line  1174 "cs.ATG" 
out stmt);
						} else if (la.kind == 10) {
							lexer.NextToken();
						} else SynErr(147);

#line  1174 "cs.ATG" 
						methodDeclaration.Body  = (BlockStatement)stmt; 
					} else {
						lexer.NextToken();

#line  1177 "cs.ATG" 
						PropertyDeclaration pDecl = new PropertyDeclaration(qualident, type, m.Modifier, attributes); 
						pDecl.StartLocation = startPos;
						pDecl.EndLocation   = qualIdentEndLocation;
						pDecl.BodyStart   = t.Location;
						PropertyGetRegion getRegion;
						PropertySetRegion setRegion;
						
						AccessorDecls(
#line  1184 "cs.ATG" 
out getRegion, out setRegion);
						Expect(15);

#line  1186 "cs.ATG" 
						pDecl.GetRegion = getRegion;
						pDecl.SetRegion = setRegion;
						pDecl.BodyEnd = t.EndLocation;
						compilationUnit.AddChild(pDecl);
						
					}
				} else if (la.kind == 13) {

#line  1194 "cs.ATG" 
					m.Check(Modifier.Indexers); 
					lexer.NextToken();
					Expect(110);
					Expect(16);
					FormalParameterList(
#line  1195 "cs.ATG" 
out p);
					Expect(17);

#line  1196 "cs.ATG" 
					IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
					indexer.StartLocation = startPos;
					indexer.EndLocation   = t.EndLocation;
					indexer.NamespaceName = qualident;
					PropertyGetRegion getRegion;
					PropertySetRegion setRegion;
					
					Expect(14);

#line  1203 "cs.ATG" 
					Point bodyStart = t.Location; 
					AccessorDecls(
#line  1204 "cs.ATG" 
out getRegion, out setRegion);
					Expect(15);

#line  1205 "cs.ATG" 
					indexer.BodyStart = bodyStart;
					indexer.BodyEnd   = t.EndLocation;
					indexer.GetRegion = getRegion;
					indexer.SetRegion = setRegion;
					compilationUnit.AddChild(indexer);
					
				} else SynErr(148);
			} else SynErr(149);
		} else SynErr(150);
	}
        public override object Visit(OperatorDeclaration operatorDeclaration, object data)
        {
            VisitAttributes(operatorDeclaration.Attributes, data);
            outputFormatter.Indent();
            VisitModifier(operatorDeclaration.Modifier);
            switch (operatorDeclaration.OpratorDeclarator.OperatorType) {
                case OperatorType.Explicit:
                    outputFormatter.PrintToken(Tokens.Explicit);
                    break;
                case OperatorType.Implicit:
                    outputFormatter.PrintToken(Tokens.Implicit);
                    break;
                default:
                    Visit(operatorDeclaration.OpratorDeclarator.TypeReference, data);
                    break;
            }
            outputFormatter.Space();
            outputFormatter.PrintToken(Tokens.Operator);
            outputFormatter.Space();
            if (!operatorDeclaration.OpratorDeclarator.IsConversion) {
                outputFormatter.PrintIdentifier(Tokens.GetTokenString(operatorDeclaration.OpratorDeclarator.OverloadOperatorToken));
            } else {
                Visit(operatorDeclaration.OpratorDeclarator.TypeReference, data);
            }

            outputFormatter.PrintToken(Tokens.OpenParenthesis);
            Visit(operatorDeclaration.OpratorDeclarator.FirstParameterType, data);
            outputFormatter.Space();
            outputFormatter.PrintIdentifier(operatorDeclaration.OpratorDeclarator.FirstParameterName);
            if (operatorDeclaration.OpratorDeclarator.OperatorType == OperatorType.Binary) {
                outputFormatter.PrintToken(Tokens.Comma);
                outputFormatter.Space();
                Visit(operatorDeclaration.OpratorDeclarator.SecondParameterType, data);
                outputFormatter.Space();
                outputFormatter.PrintIdentifier(operatorDeclaration.OpratorDeclarator.SecondParameterName);
            }
            outputFormatter.PrintToken(Tokens.CloseParenthesis);

            if (operatorDeclaration.Body == null) {
                outputFormatter.PrintToken(Tokens.Semicolon);
                outputFormatter.NewLine();
            } else {
                outputFormatter.NewLine();
                outputFormatter.Indent();
                outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
                outputFormatter.NewLine();
                ++outputFormatter.IndentationLevel;
                operatorDeclaration.Body.AcceptChildren(this, data);
                --outputFormatter.IndentationLevel;
                outputFormatter.Indent();
                outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
                outputFormatter.NewLine();
            }
            return null;
        }