public FunctionCall(Expression root, Token parenToken, IList<Expression> args, Executable owner)
			: base(root.FirstToken, owner)
		{
			this.Root = root;
			this.ParenToken = parenToken;
			this.Args = args.ToArray();
		}

		public override void TranslateGlDrawArrays(List<string> output, Expression gl, Expression vertexCount)
		{
			this.Translator.TranslateExpression(output, gl);
			output.Add(".glDrawArrays(javax.microedition.khronos.opengles.GL10.GL_TRIANGLE_STRIP, 0, ");
			this.Translator.TranslateExpression(output, vertexCount);
			output.Add(")");
		}

		public int GetLiteralId(Expression value)
		{
			if (value is NullConstant)
			{
				return GetNullConstant();
			}

			if (value is IntegerConstant)
			{
				return this.GetIntConstant(((IntegerConstant)value).Value);
			}

			if (value is FloatConstant)
			{
				return this.GetFloatConstant(((FloatConstant)value).Value);
			}

			if (value is BooleanConstant)
			{
				return this.GetBoolConstant(((BooleanConstant)value).Value);
			}

			if (value is StringConstant)
			{
				return this.GetStringConstant(((StringConstant)value).Value);
			}

			return -1;
		}

		public IfStatement(Token ifToken, Expression condition, IList<Executable> trueCode, IList<Executable> falseCode, Executable owner)
			: base(ifToken, owner)
		{
			this.Condition = condition;
			this.TrueCode = trueCode.ToArray();
			this.FalseCode = falseCode.ToArray();
		}

		public DotStep(Expression root, Token dotToken, Token stepToken, Executable owner)
			: base(root.FirstToken, owner)
		{
			this.Root = root;
			this.DotToken = dotToken;
			this.StepToken = stepToken;
		}

		public override void TranslateGlBindTexture(List<string> output, Expression gl, Expression textureId)
		{
			this.Translator.TranslateExpression(output, gl);
			output.Add(".glBindTexture(javax.microedition.khronos.opengles.GL10.GL_TEXTURE_2D, ");
			this.Translator.TranslateExpression(output, textureId);
			output.Add(")");
		}

		public override void TranslateGet2dDigitalAxisValue(List<string> output, Expression device, Expression digitalAxisIndex)
		{
			this.Translator.TranslateExpression(output, device);
			output.Add(".get_hat(");
			this.Translator.TranslateExpression(output, digitalAxisIndex);
			output.Add(")");
		}

		public override void TranslateGetButtonValue(List<string> output, Expression device, Expression buttonIndex)
		{
			this.Translator.TranslateExpression(output, device);
			output.Add(".get_button(");
			this.Translator.TranslateExpression(output, buttonIndex);
			output.Add(")");
		}

		public SwitchStatement(Token switchToken, Expression condition, List<Token> firstTokens, List<List<Expression>> cases, List<List<Executable>> code, Expression explicitMax, Token explicitMaxToken, Executable owner)
			: base(switchToken, owner)
		{
			if (cases.Count == 0) throw new ParserException(switchToken, "Switch statement needs cases.");
			if (code.Count == 0) throw new ParserException(switchToken, "Switch statement needs code.");
			if (cases[0] == null) throw new ParserException(switchToken, "Switch statement must start with a case.");
			if (cases[cases.Count - 1] != null) throw new ParserException(switchToken, "Last case in switch statement is empty.");

			this.Condition = condition;
			this.explicitMax = explicitMax;
			this.explicitMaxToken = explicitMaxToken;

			List<Chunk> chunks = new List<Chunk>();
			int counter = 0;
			for (int i = 0; i < cases.Count; i += 2)
			{
				if (cases[i] == null) throw new Exception("This should not happen.");
				if (code[i + 1] == null) throw new Exception("This should not happen.");
				Chunk chunk = new Chunk(counter++, firstTokens[i], cases[i], code[i + 1]);
				if (chunk.Code.Length > 0 && chunk.ContainsFallthrough)
				{
					throw new ParserException(firstTokens[i], "This switch statement case contains code, but falls through to the next case. Cases that contain code must end with a return or break statement.");
				}
				chunks.Add(chunk);
			}
			this.chunks = chunks.ToArray();

			if (this.chunks.Length == 1 && this.chunks[0].Cases.Length == 1 && this.chunks[0].Cases[0] == null)
			{
				throw new ParserException(switchToken, "Switches need at least 1 case to indicate type.");
			}
		}

		public override void TranslateGetAnalogAxisValue(List<string> output, Expression device, Expression analogAxisIndex)
		{
			this.Translator.TranslateExpression(output, device);
			output.Add(".get_axis(");
			this.Translator.TranslateExpression(output, analogAxisIndex);
			output.Add(")");
		}

		protected override void TranslateArrayGet(List<string> output, Expression list, Expression index)
		{
			this.Translator.TranslateExpression(output, list);
			output.Add("[");
			this.Translator.TranslateExpression(output, index);
			output.Add("]");
		}

		public BinaryOpChain(Expression left, Token op, Expression right, Executable owner)
			: base(left.FirstToken, owner)
		{
			this.Left = left;
			this.Right = right;
			this.Op = op;
		}

		public ForEachLoop(Token forToken, Token iterationVariable, Expression iterationExpression, IList<Executable> code, Executable owner)
			: base(forToken, owner)
		{
			this.IterationVariable = iterationVariable;
			this.IterationExpression = iterationExpression;
			this.Code = code.ToArray();
		}

		public ForLoop(Token forToken, IList<Executable> init, Expression condition, IList<Executable> step, IList<Executable> code, Executable owner)
			: base(forToken, owner)
		{
			this.Init = init.ToArray();
			this.Condition = condition ?? new BooleanConstant(forToken, true, owner);
			this.Step = step.ToArray();
			this.Code = code.ToArray();
		}

		public Assignment(Expression target, Token assignmentOpToken, string assignmentOp, Expression assignedValue, Executable owner)
			: base(target.FirstToken, owner)
		{
			this.Target = target;
			this.AssignmentOpToken = assignmentOpToken;
			this.AssignmentOp = assignmentOp;
			this.Value = assignedValue;
		}

		internal override Executable ResolveNames(Parser parser, Dictionary<string, Executable> lookup, string[] imports)
		{
			if (this.Expression != null)
			{
				this.Expression = this.Expression.ResolveNames(parser, lookup, imports);
			}
			return this;
		}

		internal override IList<Executable> Resolve(Parser parser)
		{
			if (this.Expression != null)
			{
				this.Expression = this.Expression.Resolve(parser);
			}
			return Listify(this);
		}

		public ConstStatement(Token constToken, Token nameToken, string ns, Expression expression, Executable owner)
			: base(constToken, owner)
		{
			this.Expression = expression;
			this.NameToken = nameToken;
			this.Name = nameToken.Value;
			this.Namespace = ns;
		}

		public override void TranslateGetButtonValue(List<string> output, Expression device, Expression buttonIndex)
		{
			output.Add("GamepadTranslationHelper.GetButtonValue(");
			this.Translator.TranslateExpression(output, device);
			output.Add(", ");
			this.Translator.TranslateExpression(output, buttonIndex);
			output.Add(")");
		}

		protected override void TranslateArraySet(List<string> output, Expression list, Expression index, Expression value)
		{
			this.Translator.TranslateExpression(output, list);
			output.Add("[");
			this.Translator.TranslateExpression(output, index);
			output.Add(this.Shorten("] = "));
			this.Translator.TranslateExpression(output, value);
		}