public override object Visit(IndexerExpression indexerExpression, object data)
 {
     DebugOutput(indexerExpression);
     return String.Concat(indexerExpression.TargetObject.AcceptVisitor(this, data),
                          GetParameters(indexerExpression.Indices));
 }
 public override object Visit(IndexerExpression indexerExpression, object data)
 {
     return new CodeIndexerExpression((CodeExpression)indexerExpression.TargetObject.AcceptVisitor(this, data), GetExpressionList(indexerExpression.Indices));
 }
 public override object Visit(IndexerExpression indexerExpression, object data)
 {
     Console.WriteLine(indexerExpression.ToString());
     return indexerExpression.AcceptChildren(this, data);
 }
        public override object Visit(IndexerExpression indexerExpression, object data)
        {
            //Console.WriteLine("TypeVisiting IndexerExpression");
            IReturnType type = (IReturnType)indexerExpression.TargetObject.AcceptVisitor(this, data);
            //Console.WriteLine("Type is " + type.FullyQualifiedName);
            if (type == null) {
                return null;
            }
            if (type.ArrayDimensions == null || type.ArrayDimensions.Length == 0) {
                //Console.WriteLine("No Array, checking indexer");
                // check if ther is an indexer
                if (indexerExpression.TargetObject is ThisReferenceExpression) {
                    if (resolver.CallingClass == null) {
                        return null;
                    }
                    type = new ReturnType(resolver.CallingClass.FullyQualifiedName);
                }
                ArrayList indexer = resolver.SearchIndexer(type);
                if (indexer.Count == 0) {
                    return null;
                }
                // TODO: get the right indexer
                return ((IIndexer)indexer[0]).ReturnType;
            }

            // TODO: what is a[0] if a is pointer to array or array of pointer ?
            if (type.ArrayDimensions[type.ArrayDimensions.Length - 1] != indexerExpression.Indices.Count) {
                //Console.WriteLine("Number of indices do not match the Array dimension");
                return null;
            }
            int[] newArray = new int[type.ArrayDimensions.Length - 1];
            Array.Copy(type.ArrayDimensions, 0, newArray, 0, type.ArrayDimensions.Length - 1);
            return new ReturnType(type.Name, newArray, type.PointerNestingLevel);
        }
 public virtual object Visit(IndexerExpression indexerExpression, object data)
 {
     object res = indexerExpression.TargetObject.AcceptVisitor(this, data);
     foreach (INode n in indexerExpression.Indices) {
         n.AcceptVisitor(this, data);
     }
     return res;
 }
	void PrimaryExpr(
#line  1824 "cs.ATG" 
out Expression pexpr) {

#line  1826 "cs.ATG" 
		TypeReference type = null;
		bool isArrayCreation = false;
		Expression expr;
		pexpr = null;
		
		switch (la.kind) {
		case 112: {
			lexer.NextToken();

#line  1833 "cs.ATG" 
			pexpr = new PrimitiveExpression(true, "true");  
			break;
		}
		case 71: {
			lexer.NextToken();

#line  1834 "cs.ATG" 
			pexpr = new PrimitiveExpression(false, "false"); 
			break;
		}
		case 89: {
			lexer.NextToken();

#line  1835 "cs.ATG" 
			pexpr = new PrimitiveExpression(null, "null");  
			break;
		}
		case 2: {
			lexer.NextToken();

#line  1836 "cs.ATG" 
			pexpr = new PrimitiveExpression(t.literalValue, t.val);  
			break;
		}
		case 1: {
			lexer.NextToken();

#line  1838 "cs.ATG" 
			pexpr = new IdentifierExpression(t.val); 
			break;
		}
		case 18: {
			lexer.NextToken();
			Expr(
#line  1840 "cs.ATG" 
out expr);
			Expect(19);

#line  1840 "cs.ATG" 
			pexpr = new ParenthesizedExpression(expr); 
			break;
		}
		case 51: case 53: case 56: case 61: case 65: case 74: case 81: case 86: case 90: case 101: case 103: case 107: case 115: case 116: case 119: {
			switch (la.kind) {
			case 51: {
				lexer.NextToken();
				break;
			}
			case 53: {
				lexer.NextToken();
				break;
			}
			case 56: {
				lexer.NextToken();
				break;
			}
			case 61: {
				lexer.NextToken();
				break;
			}
			case 65: {
				lexer.NextToken();
				break;
			}
			case 74: {
				lexer.NextToken();
				break;
			}
			case 81: {
				lexer.NextToken();
				break;
			}
			case 86: {
				lexer.NextToken();
				break;
			}
			case 90: {
				lexer.NextToken();
				break;
			}
			case 101: {
				lexer.NextToken();
				break;
			}
			case 103: {
				lexer.NextToken();
				break;
			}
			case 107: {
				lexer.NextToken();
				break;
			}
			case 115: {
				lexer.NextToken();
				break;
			}
			case 116: {
				lexer.NextToken();
				break;
			}
			case 119: {
				lexer.NextToken();
				break;
			}
			}

#line  1846 "cs.ATG" 
			string val = t.val; t.val = ""; 
			Expect(13);
			Expect(1);

#line  1846 "cs.ATG" 
			pexpr = new FieldReferenceExpression(new TypeReferenceExpression(val), t.val); 
			break;
		}
		case 110: {
			lexer.NextToken();

#line  1848 "cs.ATG" 
			pexpr = new ThisReferenceExpression(); 
			break;
		}
		case 50: {
			lexer.NextToken();

#line  1850 "cs.ATG" 
			Expression retExpr = new BaseReferenceExpression(); 
			if (la.kind == 13) {
				lexer.NextToken();
				Expect(1);

#line  1852 "cs.ATG" 
				retExpr = new FieldReferenceExpression(retExpr, t.val); 
			} else if (la.kind == 16) {
				lexer.NextToken();
				Expr(
#line  1853 "cs.ATG" 
out expr);

#line  1853 "cs.ATG" 
				ArrayList indices = new ArrayList(); indices.Add(expr); 
				while (la.kind == 12) {
					lexer.NextToken();
					Expr(
#line  1854 "cs.ATG" 
out expr);

#line  1854 "cs.ATG" 
					indices.Add(expr); 
				}
				Expect(17);

#line  1855 "cs.ATG" 
				retExpr = new IndexerExpression(retExpr, indices); 
			} else SynErr(179);

#line  1856 "cs.ATG" 
			pexpr = retExpr; 
			break;
		}
		case 88: {
			lexer.NextToken();
			NonArrayType(
#line  1857 "cs.ATG" 
out type);

#line  1857 "cs.ATG" 
			ArrayList parameters = new ArrayList(); 
			if (la.kind == 18) {
				lexer.NextToken();

#line  1862 "cs.ATG" 
				ObjectCreateExpression oce = new ObjectCreateExpression(type, parameters); 
				if (StartOf(21)) {
					Argument(
#line  1862 "cs.ATG" 
out expr);

#line  1862 "cs.ATG" 
					parameters.Add(expr); 
					while (la.kind == 12) {
						lexer.NextToken();
						Argument(
#line  1863 "cs.ATG" 
out expr);

#line  1863 "cs.ATG" 
						parameters.Add(expr); 
					}
				}
				Expect(19);

#line  1863 "cs.ATG" 
				pexpr = oce; 
			} else if (la.kind == 16) {

#line  1865 "cs.ATG" 
				isArrayCreation = true; ArrayCreateExpression ace = new ArrayCreateExpression(type); pexpr = ace; 
				lexer.NextToken();

#line  1866 "cs.ATG" 
				int dims = 0; ArrayList rank = new ArrayList(); ArrayList parameterExpression = new ArrayList(); 
				if (StartOf(4)) {
					Expr(
#line  1868 "cs.ATG" 
out expr);

#line  1868 "cs.ATG" 
					parameterExpression.Add(expr); 
					while (la.kind == 12) {
						lexer.NextToken();
						Expr(
#line  1868 "cs.ATG" 
out expr);

#line  1868 "cs.ATG" 
						parameterExpression.Add(expr); 
					}
					Expect(17);

#line  1868 "cs.ATG" 
					parameters.Add(new ArrayCreationParameter(parameterExpression)); ace.Parameters = parameters; 
					while (
#line  1869 "cs.ATG" 
IsDims()) {
						Expect(16);

#line  1869 "cs.ATG" 
						dims =0;
						while (la.kind == 12) {
							lexer.NextToken();

#line  1869 "cs.ATG" 
							dims++;
						}

#line  1869 "cs.ATG" 
						rank.Add(dims); parameters.Add(new ArrayCreationParameter(dims)); 
						Expect(17);
					}

#line  1870 "cs.ATG" 
					if (rank.Count > 0) { ace.Rank = (int[])rank.ToArray(typeof (int)); } 
					if (la.kind == 14) {
						ArrayInitializer(
#line  1871 "cs.ATG" 
out expr);

#line  1871 "cs.ATG" 
						ace.ArrayInitializer = (ArrayInitializerExpression)expr; 
					}
				} else if (la.kind == 12 || la.kind == 17) {
					while (la.kind == 12) {
						lexer.NextToken();

#line  1873 "cs.ATG" 
						dims++;
					}

#line  1873 "cs.ATG" 
					parameters.Add(new ArrayCreationParameter(dims)); 
					Expect(17);
					while (
#line  1873 "cs.ATG" 
IsDims()) {
						Expect(16);

#line  1873 "cs.ATG" 
						dims =0;
						while (la.kind == 12) {
							lexer.NextToken();

#line  1873 "cs.ATG" 
							dims++;
						}

#line  1873 "cs.ATG" 
						parameters.Add(new ArrayCreationParameter(dims)); 
						Expect(17);
					}
					ArrayInitializer(
#line  1873 "cs.ATG" 
out expr);

#line  1873 "cs.ATG" 
					ace.ArrayInitializer = (ArrayInitializerExpression)expr; ace.Parameters = parameters; 
				} else SynErr(180);
			} else SynErr(181);
			break;
		}
		case 114: {
			lexer.NextToken();
			Expect(18);
			if (
#line  1879 "cs.ATG" 
NotVoidPointer()) {
				Expect(122);

#line  1879 "cs.ATG" 
				type = new TypeReference("void"); 
			} else if (StartOf(8)) {
				Type(
#line  1880 "cs.ATG" 
out type);
			} else SynErr(182);
			Expect(19);

#line  1881 "cs.ATG" 
			pexpr = new TypeOfExpression(type); 
			break;
		}
		case 104: {
			lexer.NextToken();
			Expect(18);
			Type(
#line  1882 "cs.ATG" 
out type);
			Expect(19);

#line  1882 "cs.ATG" 
			pexpr = new SizeOfExpression(type); 
			break;
		}
		case 57: {
			lexer.NextToken();
			Expect(18);
			Expr(
#line  1883 "cs.ATG" 
out expr);
			Expect(19);

#line  1883 "cs.ATG" 
			pexpr = new CheckedExpression(expr); 
			break;
		}
		case 117: {
			lexer.NextToken();
			Expect(18);
			Expr(
#line  1884 "cs.ATG" 
out expr);
			Expect(19);

#line  1884 "cs.ATG" 
			pexpr = new CheckedExpression(expr); 
			break;
		}
		default: SynErr(183); break;
		}
		while (StartOf(27)) {
			if (la.kind == 29 || la.kind == 30) {
				if (la.kind == 29) {
					lexer.NextToken();

#line  1888 "cs.ATG" 
					pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement); 
				} else if (la.kind == 30) {
					lexer.NextToken();

#line  1889 "cs.ATG" 
					pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement); 
				} else SynErr(184);
			} else if (la.kind == 47) {
				lexer.NextToken();
				Expect(1);

#line  1892 "cs.ATG" 
				pexpr = new PointerReferenceExpression(pexpr, t.val); 
			} else if (la.kind == 13) {
				lexer.NextToken();
				Expect(1);

#line  1893 "cs.ATG" 
				pexpr = new FieldReferenceExpression(pexpr, t.val);
			} else if (la.kind == 18) {
				lexer.NextToken();

#line  1895 "cs.ATG" 
				ArrayList parameters = new ArrayList(); 
				if (StartOf(21)) {
					Argument(
#line  1896 "cs.ATG" 
out expr);

#line  1896 "cs.ATG" 
					parameters.Add(expr); 
					while (la.kind == 12) {
						lexer.NextToken();
						Argument(
#line  1897 "cs.ATG" 
out expr);

#line  1897 "cs.ATG" 
						parameters.Add(expr); 
					}
				}
				Expect(19);

#line  1898 "cs.ATG" 
				pexpr = new InvocationExpression(pexpr, parameters); 
			} else {

#line  1900 "cs.ATG" 
				if (isArrayCreation) Error("element access not allow on array creation");
				ArrayList indices = new ArrayList();
				
				lexer.NextToken();
				Expr(
#line  1903 "cs.ATG" 
out expr);

#line  1903 "cs.ATG" 
				indices.Add(expr); 
				while (la.kind == 12) {
					lexer.NextToken();
					Expr(
#line  1904 "cs.ATG" 
out expr);

#line  1904 "cs.ATG" 
					indices.Add(expr); 
				}
				Expect(17);

#line  1905 "cs.ATG" 
				pexpr = new IndexerExpression(pexpr, indices); 
			}
		}
	}
 public override object Visit(IndexerExpression indexerExpression, object data)
 {
     indexerExpression.TargetObject.AcceptVisitor(this, data);
     outputFormatter.PrintToken(Tokens.OpenSquareBracket);
     AppendCommaSeparatedList(indexerExpression.Indices);
     outputFormatter.PrintToken(Tokens.CloseSquareBracket);
     return null;
 }