Cleanup whitespace

1 files changed, 400 insertions, 400 deletions

diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java
index 4241ce2..289f99d 100644
--- a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java
+++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java
@@ -93,409 +93,409 @@ import pl.edu.mimuw.cloudatlas.model.ValueString;
 import pl.edu.mimuw.cloudatlas.model.ZMI;
 
 public class Interpreter {
-	private static class ValuesPair {
-		public final Result left;
-		public final Result right;
-
-		public ValuesPair(Result left, Result right) {
-			this.left = left;
-			this.right = right;
-		}
-	}
-
-	private final ZMI zmi;
-
-	public Interpreter(ZMI zmi) {
-		this.zmi = zmi;
-	}
-
-	private static Boolean getBoolean(Value value) {
-		if(value.getType().isCompatible(TypePrimitive.BOOLEAN)) {
-			Boolean b = ((ValueBoolean)value).getValue();
-			return b == null? false : b.booleanValue();
-		}
-		throw new InvalidTypeException(TypePrimitive.BOOLEAN, value.getType());
-	}
-
-	public List<QueryResult> interpretProgram(Program program) {
-		return program.accept(new ProgramInterpreter(), zmi);
-	}
-
-	public List<QueryResult> interpretStatement(Statement statement) {
-		return statement.accept(new StatementInterpreter(), zmi);
-	}
-
-	public class ProgramInterpreter implements Program.Visitor<List<QueryResult>, ZMI> {
-		public List<QueryResult> visit(ProgramC program, ZMI zmi) {
-			List<QueryResult> results = new ArrayList<QueryResult>();
-			for(Statement s : program.liststatement_) {
-				try {
-					List<QueryResult> l = s.accept(new StatementInterpreter(), zmi);
-					for(QueryResult qr : l)
-						if(qr.getName() == null)
-							throw new IllegalArgumentException("All items in top-level SELECT must be aliased.");
-					results.addAll(l);
-				} catch(Exception exception) {
-					throw new InsideQueryException(PrettyPrinter.print(s), exception);
-				}
-			}
-			return results;
-		}
-	}
-
-	public class StatementInterpreter implements Statement.Visitor<List<QueryResult>, ZMI> {
-		public List<QueryResult> visit(StatementC statement, ZMI zmi) {
-			Table table = new Table(zmi);
-			try {
-				table = statement.where_.accept(new WhereInterpreter(), table);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(statement.where_), exception);
-			}
-			try {
-				table = statement.orderby_.accept(new OrderByInterpreter(), table);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(statement.orderby_), exception);
-			}
-			List<QueryResult> ret = new ArrayList<QueryResult>();
-
-			for(SelItem selItem : statement.listselitem_) {
-				try {
-					QueryResult qr = selItem.accept(new SelItemInterpreter(), table);
-					if(qr.getName() != null) {
-						for(QueryResult qrRet : ret)
-							if(qr.getName().getName().equals(qrRet.getName().getName()))
-								throw new IllegalArgumentException("Alias collision.");
-					}
-					ret.add(qr);
-				} catch(Exception exception) {
-					throw new InsideQueryException(PrettyPrinter.print(selItem), exception);
-				}
-			}
-
-			return ret;
-		}
-	}
-
-	public class WhereInterpreter implements Where.Visitor<Table, Table> {
-		public Table visit(NoWhereC where, Table table) {
-			return table;
-		}
-
-		public Table visit(WhereC where, Table table) {
-			Table result = new Table(table);
-			for(TableRow row : table) {
-				Environment env = new EnvironmentRow(row, table.getColumns());
-				Value value = where.condexpr_.accept(new CondExprInterpreter(), env).getValue();
-				if(getBoolean(value))
-					result.appendRow(row);
-			}
-			return result;
-		}
-	}
-
-	public class OrderByInterpreter implements OrderBy.Visitor<Table, Table> {
-		public Table visit(NoOrderByC orderBy, Table table) {
-			return table;
-		}
-
-		public Table visit(OrderByC orderBy, Table table) {
-			for(OrderItem item : orderBy.listorderitem_) {
-				try {
-					table = item.accept(new OrderItemInterpreter(), table);
-				} catch(Exception exception) {
-					throw new InsideQueryException(PrettyPrinter.print(item), exception);
-				}
-			}
-			return table;
-		}
-	}
-
-	public class OrderItemInterpreter implements OrderItem.Visitor<Table, Table> {
-		public Table visit(final OrderItemC orderItem, final Table table) {
-			Comparator<TableRow> comparator = new Comparator<TableRow>() {
-				@Override
-				public int compare(TableRow row1, TableRow row2) {
-					Environment env1 = new EnvironmentRow(row1, table.getColumns());
-					Result expr1 = orderItem.condexpr_.accept(new CondExprInterpreter(), env1);
-					Environment env2 = new EnvironmentRow(row2, table.getColumns());
-					Result expr2 = orderItem.condexpr_.accept(new CondExprInterpreter(), env2);
-					ValuesPair pair = new ValuesPair(expr1, expr2);
-					int result = orderItem.nulls_.accept(new NullsInterpreter(), pair);
-					if(result == 0)
-						result = orderItem.order_.accept(new OrderInterpreter(), pair);
-					return result;
-				}
-			};
-			table.sort(comparator);
-			return table;
-		}
-	}
-
-	public class OrderInterpreter implements Order.Visitor<Integer, ValuesPair> {
-		private int compareAsc(ValuesPair pair) {
-			if(getBoolean(pair.left.isEqual(pair.right).getValue()))
-				return 0;
-			if(getBoolean(pair.left.isLowerThan(pair.right).getValue()))
-				return -1;
-			return 1;
-		}
-
-		public Integer visit(AscOrderC order, ValuesPair pair) {
-			return compareAsc(pair);
-		}
-
-		public Integer visit(DescOrderC order, ValuesPair pair) {
-			return -compareAsc(pair);
-		}
-
-		public Integer visit(NoOrderC order, ValuesPair pair) {
-			return compareAsc(pair);
-		}
-	}
-
-	public class NullsInterpreter implements Nulls.Visitor<Integer, ValuesPair> {
-		private Integer nullsFirst(ValuesPair pair) {
-			if(pair.left.getValue().isNull()) {
-				if(pair.right.getValue().isNull())
-					return 0;
-				return -1;
-			}
-			if(pair.right.getValue().isNull())
-				return 1;
-			return 0;
-		}
-
-		public Integer visit(NoNullsC nulls, ValuesPair pair) {
-			return nullsFirst(pair);
-		}
-
-		public Integer visit(NullFirstsC nulls, ValuesPair pair) {
-			return nullsFirst(pair);
-		}
-
-		public Integer visit(NullsLastC nulls, ValuesPair pair) {
-			return -nullsFirst(pair);
-		}
-	}
-
-	public class SelItemInterpreter implements SelItem.Visitor<QueryResult, Table> {
-		public QueryResult visit(SelItemC selItem, Table table) {
-			Environment env = new EnvironmentTable(table);
-			Result result = selItem.condexpr_.accept(new CondExprInterpreter(), env);
-			return new QueryResult(result.getValue());
-		}
-
-		public QueryResult visit(AliasedSelItemC selItem, Table table) {
-			Environment env = new EnvironmentTable(table);
-			Result result = selItem.condexpr_.accept(new CondExprInterpreter(), env);
-			return new QueryResult(new Attribute(selItem.qident_), result.getValue());
-		}
-	}
-
-	public class BoolExprInterpreter implements BoolExpr.Visitor<Result, Environment> {
-		public Result visit(BoolExprCmpC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return expr.relop_.accept(new RelOpInterpreter(), new ValuesPair(left, right));
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BoolExprRegExpC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_.accept(new BasicExprInterpreter(), env);
-				return (new ResultSingle(new ValueString(expr.string_))).regExpr(left);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BoolExprBasicExprC expr, Environment env) {
-			return expr.basicexpr_.accept(new BasicExprInterpreter(), env);
-		}
-	}
-
-	public class CondExprInterpreter implements CondExpr.Visitor<Result, Environment> {
-		public Result visit(CondExprOrC expr, Environment env) {
-			try {
-				Result left = expr.condexpr_1.accept(new CondExprInterpreter(), env);
-				Result right = expr.condexpr_2.accept(new CondExprInterpreter(), env);
-				return left.or(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(CondExprAndC expr, Environment env) {
-			// TODO
-			throw new UnsupportedOperationException("CondExprAndC Not yet implemented");
-		}
-
-		public Result visit(CondExprNotC expr, Environment env) {
-			try {
-				return expr.condexpr_.accept(new CondExprInterpreter(), env).negate();
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(CondExprBoolExprC expr, Environment env) {
-			return expr.boolexpr_.accept(new BoolExprInterpreter(), env);
-		}
-	}
-
-	public class BasicExprInterpreter implements BasicExpr.Visitor<Result, Environment> {
-		public Result visit(BasicExprAddC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return left.addValue(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BasicExprSubC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return left.subtract(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BasicExprMulC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return left.multiply(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BasicExprDivC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return left.divide(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BasicExprModC expr, Environment env) {
-			try {
-				Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
-				Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
-				return left.modulo(right);
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(BasicExprNegC expr, Environment env) {
-			try {
-				return expr.basicexpr_.accept(new BasicExprInterpreter(), env).negate();
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public Result visit(EIdentC expr, Environment env) {
-			Result res = env.getIdent(expr.qident_);
+    private static class ValuesPair {
+        public final Result left;
+        public final Result right;
+
+        public ValuesPair(Result left, Result right) {
+            this.left = left;
+            this.right = right;
+        }
+    }
+
+    private final ZMI zmi;
+
+    public Interpreter(ZMI zmi) {
+        this.zmi = zmi;
+    }
+
+    private static Boolean getBoolean(Value value) {
+        if(value.getType().isCompatible(TypePrimitive.BOOLEAN)) {
+            Boolean b = ((ValueBoolean)value).getValue();
+            return b == null? false : b.booleanValue();
+        }
+        throw new InvalidTypeException(TypePrimitive.BOOLEAN, value.getType());
+    }
+
+    public List<QueryResult> interpretProgram(Program program) {
+        return program.accept(new ProgramInterpreter(), zmi);
+    }
+
+    public List<QueryResult> interpretStatement(Statement statement) {
+        return statement.accept(new StatementInterpreter(), zmi);
+    }
+
+    public class ProgramInterpreter implements Program.Visitor<List<QueryResult>, ZMI> {
+        public List<QueryResult> visit(ProgramC program, ZMI zmi) {
+            List<QueryResult> results = new ArrayList<QueryResult>();
+            for(Statement s : program.liststatement_) {
+                try {
+                    List<QueryResult> l = s.accept(new StatementInterpreter(), zmi);
+                    for(QueryResult qr : l)
+                        if(qr.getName() == null)
+                            throw new IllegalArgumentException("All items in top-level SELECT must be aliased.");
+                    results.addAll(l);
+                } catch(Exception exception) {
+                    throw new InsideQueryException(PrettyPrinter.print(s), exception);
+                }
+            }
+            return results;
+        }
+    }
+
+    public class StatementInterpreter implements Statement.Visitor<List<QueryResult>, ZMI> {
+        public List<QueryResult> visit(StatementC statement, ZMI zmi) {
+            Table table = new Table(zmi);
+            try {
+                table = statement.where_.accept(new WhereInterpreter(), table);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(statement.where_), exception);
+            }
+            try {
+                table = statement.orderby_.accept(new OrderByInterpreter(), table);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(statement.orderby_), exception);
+            }
+            List<QueryResult> ret = new ArrayList<QueryResult>();
+
+            for(SelItem selItem : statement.listselitem_) {
+                try {
+                    QueryResult qr = selItem.accept(new SelItemInterpreter(), table);
+                    if(qr.getName() != null) {
+                        for(QueryResult qrRet : ret)
+                            if(qr.getName().getName().equals(qrRet.getName().getName()))
+                                throw new IllegalArgumentException("Alias collision.");
+                    }
+                    ret.add(qr);
+                } catch(Exception exception) {
+                    throw new InsideQueryException(PrettyPrinter.print(selItem), exception);
+                }
+            }
+
+            return ret;
+        }
+    }
+
+    public class WhereInterpreter implements Where.Visitor<Table, Table> {
+        public Table visit(NoWhereC where, Table table) {
+            return table;
+        }
+
+        public Table visit(WhereC where, Table table) {
+            Table result = new Table(table);
+            for(TableRow row : table) {
+                Environment env = new EnvironmentRow(row, table.getColumns());
+                Value value = where.condexpr_.accept(new CondExprInterpreter(), env).getValue();
+                if(getBoolean(value))
+                    result.appendRow(row);
+            }
+            return result;
+        }
+    }
+
+    public class OrderByInterpreter implements OrderBy.Visitor<Table, Table> {
+        public Table visit(NoOrderByC orderBy, Table table) {
+            return table;
+        }
+
+        public Table visit(OrderByC orderBy, Table table) {
+            for(OrderItem item : orderBy.listorderitem_) {
+                try {
+                    table = item.accept(new OrderItemInterpreter(), table);
+                } catch(Exception exception) {
+                    throw new InsideQueryException(PrettyPrinter.print(item), exception);
+                }
+            }
+            return table;
+        }
+    }
+
+    public class OrderItemInterpreter implements OrderItem.Visitor<Table, Table> {
+        public Table visit(final OrderItemC orderItem, final Table table) {
+            Comparator<TableRow> comparator = new Comparator<TableRow>() {
+                @Override
+                public int compare(TableRow row1, TableRow row2) {
+                    Environment env1 = new EnvironmentRow(row1, table.getColumns());
+                    Result expr1 = orderItem.condexpr_.accept(new CondExprInterpreter(), env1);
+                    Environment env2 = new EnvironmentRow(row2, table.getColumns());
+                    Result expr2 = orderItem.condexpr_.accept(new CondExprInterpreter(), env2);
+                    ValuesPair pair = new ValuesPair(expr1, expr2);
+                    int result = orderItem.nulls_.accept(new NullsInterpreter(), pair);
+                    if(result == 0)
+                        result = orderItem.order_.accept(new OrderInterpreter(), pair);
+                    return result;
+                }
+            };
+            table.sort(comparator);
+            return table;
+        }
+    }
+
+    public class OrderInterpreter implements Order.Visitor<Integer, ValuesPair> {
+        private int compareAsc(ValuesPair pair) {
+            if(getBoolean(pair.left.isEqual(pair.right).getValue()))
+                return 0;
+            if(getBoolean(pair.left.isLowerThan(pair.right).getValue()))
+                return -1;
+            return 1;
+        }
+
+        public Integer visit(AscOrderC order, ValuesPair pair) {
+            return compareAsc(pair);
+        }
+
+        public Integer visit(DescOrderC order, ValuesPair pair) {
+            return -compareAsc(pair);
+        }
+
+        public Integer visit(NoOrderC order, ValuesPair pair) {
+            return compareAsc(pair);
+        }
+    }
+
+    public class NullsInterpreter implements Nulls.Visitor<Integer, ValuesPair> {
+        private Integer nullsFirst(ValuesPair pair) {
+            if(pair.left.getValue().isNull()) {
+                if(pair.right.getValue().isNull())
+                    return 0;
+                return -1;
+            }
+            if(pair.right.getValue().isNull())
+                return 1;
+            return 0;
+        }
+
+        public Integer visit(NoNullsC nulls, ValuesPair pair) {
+            return nullsFirst(pair);
+        }
+
+        public Integer visit(NullFirstsC nulls, ValuesPair pair) {
+            return nullsFirst(pair);
+        }
+
+        public Integer visit(NullsLastC nulls, ValuesPair pair) {
+            return -nullsFirst(pair);
+        }
+    }
+
+    public class SelItemInterpreter implements SelItem.Visitor<QueryResult, Table> {
+        public QueryResult visit(SelItemC selItem, Table table) {
+            Environment env = new EnvironmentTable(table);
+            Result result = selItem.condexpr_.accept(new CondExprInterpreter(), env);
+            return new QueryResult(result.getValue());
+        }
+
+        public QueryResult visit(AliasedSelItemC selItem, Table table) {
+            Environment env = new EnvironmentTable(table);
+            Result result = selItem.condexpr_.accept(new CondExprInterpreter(), env);
+            return new QueryResult(new Attribute(selItem.qident_), result.getValue());
+        }
+    }
+
+    public class BoolExprInterpreter implements BoolExpr.Visitor<Result, Environment> {
+        public Result visit(BoolExprCmpC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return expr.relop_.accept(new RelOpInterpreter(), new ValuesPair(left, right));
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BoolExprRegExpC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_.accept(new BasicExprInterpreter(), env);
+                return (new ResultSingle(new ValueString(expr.string_))).regExpr(left);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BoolExprBasicExprC expr, Environment env) {
+            return expr.basicexpr_.accept(new BasicExprInterpreter(), env);
+        }
+    }
+
+    public class CondExprInterpreter implements CondExpr.Visitor<Result, Environment> {
+        public Result visit(CondExprOrC expr, Environment env) {
+            try {
+                Result left = expr.condexpr_1.accept(new CondExprInterpreter(), env);
+                Result right = expr.condexpr_2.accept(new CondExprInterpreter(), env);
+                return left.or(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(CondExprAndC expr, Environment env) {
+            // TODO
+            throw new UnsupportedOperationException("CondExprAndC Not yet implemented");
+        }
+
+        public Result visit(CondExprNotC expr, Environment env) {
+            try {
+                return expr.condexpr_.accept(new CondExprInterpreter(), env).negate();
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(CondExprBoolExprC expr, Environment env) {
+            return expr.boolexpr_.accept(new BoolExprInterpreter(), env);
+        }
+    }
+
+    public class BasicExprInterpreter implements BasicExpr.Visitor<Result, Environment> {
+        public Result visit(BasicExprAddC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return left.addValue(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BasicExprSubC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return left.subtract(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BasicExprMulC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return left.multiply(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BasicExprDivC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return left.divide(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BasicExprModC expr, Environment env) {
+            try {
+                Result left = expr.basicexpr_1.accept(new BasicExprInterpreter(), env);
+                Result right = expr.basicexpr_2.accept(new BasicExprInterpreter(), env);
+                return left.modulo(right);
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(BasicExprNegC expr, Environment env) {
+            try {
+                return expr.basicexpr_.accept(new BasicExprInterpreter(), env).negate();
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public Result visit(EIdentC expr, Environment env) {
+            Result res = env.getIdent(expr.qident_);
             return res;
-		}
+        }
 
-		public Result visit(EFunC expr, Environment env) {
-			try {
-				List<Result> arguments = new ArrayList<Result>(expr.listcondexpr_.size());
-				for(CondExpr arg : expr.listcondexpr_) {
-					arguments.add(arg.accept(new CondExprInterpreter(), env));
+        public Result visit(EFunC expr, Environment env) {
+            try {
+                List<Result> arguments = new ArrayList<Result>(expr.listcondexpr_.size());
+                for(CondExpr arg : expr.listcondexpr_) {
+                    arguments.add(arg.accept(new CondExprInterpreter(), env));
                 }
 
-				Result res = Functions.getInstance().evaluate(expr.qident_, arguments);
+                Result res = Functions.getInstance().evaluate(expr.qident_, arguments);
                 return res;
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-
-		public ResultSingle visit(EStrC expr, Environment env) {
-			return new ResultSingle(new ValueString(expr.string_));
-		}
-
-		public ResultSingle visit(EBoolC expr, Environment env) {
-			ValueBoolean value;
-			if(expr.qbool_.compareTo("true") == 0)
-				value = new ValueBoolean(true);
-			else if(expr.qbool_.compareTo("false") == 0)
-				value = new ValueBoolean(false);
-			else
-				throw new InternalInterpreterException("Incorrect boolean constant: " + PrettyPrinter.print(expr));
-			return new ResultSingle(value);
-		}
-
-		public ResultSingle visit(EIntC expr, Environment env) {
-			try {
-				return new ResultSingle(new ValueInt(Long.parseLong(expr.qinteger_)));
-			} catch(NumberFormatException exception) {
-				throw new InternalInterpreterException(exception.getMessage());
-			}
-		}
-
-		public ResultSingle visit(EDblC expr, Environment env) {
-			try {
-				return new ResultSingle(new ValueDouble(Double.parseDouble(expr.qdouble_)));
-			} catch(NumberFormatException exception) {
-				throw new InternalInterpreterException(exception.getMessage());
-			}
-		}
-
-		public Result visit(ECondExprC expr, Environment env) {
-			return expr.condexpr_.accept(new CondExprInterpreter(), env);
-		}
-
-		public ResultSingle visit(EStmtC expr, Environment env) {
-			try {
-				List<QueryResult> l = expr.statement_.accept(new StatementInterpreter(), zmi);
-				if(l.size() != 1)
-					throw new IllegalArgumentException("Nested queries must SELECT exactly one item.");
-				return new ResultSingle(l.get(0).getValue());
-			} catch(Exception exception) {
-				throw new InsideQueryException(PrettyPrinter.print(expr), exception);
-			}
-		}
-	}
-
-	public class RelOpInterpreter implements RelOp.Visitor<Result, ValuesPair> {
-		public Result visit(RelOpGtC op, ValuesPair pair) {
-			return pair.left.isLowerThan(pair.right).negate().and(pair.left.isEqual(pair.right).negate());
-		}
-
-		public Result visit(RelOpEqC op, ValuesPair pair) {
-			// TODO
-			throw new UnsupportedOperationException("RelOpEqC Not yet implemented");
-		}
-
-		public Result visit(RelOpNeC op, ValuesPair pair) {
-			return pair.left.isEqual(pair.right).negate();
-		}
-
-		public Result visit(RelOpLtC op, ValuesPair pair) {
-			return pair.left.isLowerThan(pair.right);
-		}
-
-		public Result visit(RelOpLeC op, ValuesPair pair) {
-			// TODO
-			throw new UnsupportedOperationException("RelOpLeC Not yet implemented");
-		}
-
-		public Result visit(RelOpGeC op, ValuesPair pair) {
-			return pair.left.isLowerThan(pair.right).negate();
-		}
-	}
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+
+        public ResultSingle visit(EStrC expr, Environment env) {
+            return new ResultSingle(new ValueString(expr.string_));
+        }
+
+        public ResultSingle visit(EBoolC expr, Environment env) {
+            ValueBoolean value;
+            if(expr.qbool_.compareTo("true") == 0)
+                value = new ValueBoolean(true);
+            else if(expr.qbool_.compareTo("false") == 0)
+                value = new ValueBoolean(false);
+            else
+                throw new InternalInterpreterException("Incorrect boolean constant: " + PrettyPrinter.print(expr));
+            return new ResultSingle(value);
+        }
+
+        public ResultSingle visit(EIntC expr, Environment env) {
+            try {
+                return new ResultSingle(new ValueInt(Long.parseLong(expr.qinteger_)));
+            } catch(NumberFormatException exception) {
+                throw new InternalInterpreterException(exception.getMessage());
+            }
+        }
+
+        public ResultSingle visit(EDblC expr, Environment env) {
+            try {
+                return new ResultSingle(new ValueDouble(Double.parseDouble(expr.qdouble_)));
+            } catch(NumberFormatException exception) {
+                throw new InternalInterpreterException(exception.getMessage());
+            }
+        }
+
+        public Result visit(ECondExprC expr, Environment env) {
+            return expr.condexpr_.accept(new CondExprInterpreter(), env);
+        }
+
+        public ResultSingle visit(EStmtC expr, Environment env) {
+            try {
+                List<QueryResult> l = expr.statement_.accept(new StatementInterpreter(), zmi);
+                if(l.size() != 1)
+                    throw new IllegalArgumentException("Nested queries must SELECT exactly one item.");
+                return new ResultSingle(l.get(0).getValue());
+            } catch(Exception exception) {
+                throw new InsideQueryException(PrettyPrinter.print(expr), exception);
+            }
+        }
+    }
+
+    public class RelOpInterpreter implements RelOp.Visitor<Result, ValuesPair> {
+        public Result visit(RelOpGtC op, ValuesPair pair) {
+            return pair.left.isLowerThan(pair.right).negate().and(pair.left.isEqual(pair.right).negate());
+        }
+
+        public Result visit(RelOpEqC op, ValuesPair pair) {
+            // TODO
+            throw new UnsupportedOperationException("RelOpEqC Not yet implemented");
+        }
+
+        public Result visit(RelOpNeC op, ValuesPair pair) {
+            return pair.left.isEqual(pair.right).negate();
+        }
+
+        public Result visit(RelOpLtC op, ValuesPair pair) {
+            return pair.left.isLowerThan(pair.right);
+        }
+
+        public Result visit(RelOpLeC op, ValuesPair pair) {
+            // TODO
+            throw new UnsupportedOperationException("RelOpLeC Not yet implemented");
+        }
+
+        public Result visit(RelOpGeC op, ValuesPair pair) {
+            return pair.left.isLowerThan(pair.right).negate();
+        }
+    }
 }