diff options
Diffstat (limited to 'src')
79 files changed, 6333 insertions, 0 deletions
diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Environment.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Environment.java new file mode 100644 index 0000000..d45b600 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Environment.java @@ -0,0 +1,51 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import pl.edu.mimuw.cloudatlas.model.ValueNull; + +class Environment { + private final TableRow row; + private final Map<String, Integer> columns = new HashMap<String, Integer>(); + + public Environment(TableRow row, List<String> columns) { + this.row = row; + int i = 0; + for(String c : columns) + this.columns.put(c, i++); + } + + public Result getIdent(String ident) { + try { + return new ResultSingle(row.getIth(columns.get(ident))); + } catch(NullPointerException exception) { + return new ResultSingle(ValueNull.getInstance()); + } + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java new file mode 100644 index 0000000..dde84fe --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Functions.java @@ -0,0 +1,428 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.text.ParseException; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import pl.edu.mimuw.cloudatlas.interpreter.Result.AggregationOperation; +import pl.edu.mimuw.cloudatlas.interpreter.Result.TransformOperation; +import pl.edu.mimuw.cloudatlas.interpreter.Result.UnaryOperation; +import pl.edu.mimuw.cloudatlas.model.Type; +import pl.edu.mimuw.cloudatlas.model.Type.PrimaryType; +import pl.edu.mimuw.cloudatlas.model.TypeCollection; +import pl.edu.mimuw.cloudatlas.model.TypePrimitive; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueBoolean; +import pl.edu.mimuw.cloudatlas.model.ValueDouble; +import pl.edu.mimuw.cloudatlas.model.ValueInt; +import pl.edu.mimuw.cloudatlas.model.ValueList; +import pl.edu.mimuw.cloudatlas.model.ValueNull; +import pl.edu.mimuw.cloudatlas.model.ValueSet; +import pl.edu.mimuw.cloudatlas.model.ValueTime; + +class Functions { + private static Functions instance = null; + + private static final UnaryOperation ROUND = new UnaryOperation() { + @Override + public Value perform(Value v) { + if(v.getType().isCompatible(TypePrimitive.DOUBLE)) { + if(v.isNull()) + return new ValueDouble(null); + return new ValueDouble((double)Math.round(((ValueDouble)v).getValue())); + } + throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + "."); + } + }; + + private static final UnaryOperation FLOOR = new UnaryOperation() { + @Override + public Value perform(Value v) { + if(v.getType().isCompatible(TypePrimitive.DOUBLE)) { + if(v.isNull()) + return new ValueDouble(null); + return new ValueDouble((double)Math.floor(((ValueDouble)v).getValue())); + } + throw new IllegalArgumentException("Value must have type " + TypePrimitive.DOUBLE + "."); + } + }; + + private static final UnaryOperation CEIL = new UnaryOperation() { + @Override + public Value perform(Value v) { + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + }; + + private static final AggregationOperation COUNT = new AggregationOperation() { + @Override + public ValueInt perform(ValueList values) { + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null) { + return new ValueInt(null); + } + return new ValueInt((long)nlist.size()); + } + }; + + private static final AggregationOperation SUM = new AggregationOperation() { + @Override + public Value perform(ValueList values) { + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + }; + + private static final AggregationOperation AVERAGE = new AggregationOperation() { + @Override + public Value perform(ValueList values) { + Type elementType = ((TypeCollection)values.getType()).getElementType(); + PrimaryType primaryType = elementType.getPrimaryType(); + + if(primaryType != PrimaryType.INT && primaryType != PrimaryType.DOUBLE && primaryType != PrimaryType.DURATION + && primaryType != PrimaryType.NULL) { + throw new IllegalArgumentException("Aggregation doesn't support type: " + elementType + "."); + } + + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null || nlist.isEmpty()) { + return ValueNull.getInstance(); + } + + Value result = nlist.get(0).getDefaultValue(); + + for(Value v : nlist) { + result = result.addValue(v); + } + Value size = primaryType == PrimaryType.DOUBLE? new ValueDouble((double)nlist.size()) : new ValueInt( + (long)nlist.size()); + return result.divide(size); + } + }; + + private static final AggregationOperation AND = new AggregationOperation() { + @Override + public ValueBoolean perform(ValueList values) { // lazy + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null) { + return new ValueBoolean(null); + } else if(values.isEmpty()) { + return new ValueBoolean(true); + } + for(Value v : nlist) { + if(v.getType().isCompatible(TypePrimitive.BOOLEAN)) { + if(v.isNull() || !((ValueBoolean)v).getValue()) + return new ValueBoolean(false); + } else + throw new IllegalArgumentException("Aggregation doesn't support type: " + v.getType() + "."); + } + return new ValueBoolean(true); + } + }; + + private static final AggregationOperation OR = new AggregationOperation() { + @Override + public ValueBoolean perform(ValueList values) { // lazy + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + }; + + private static final AggregationOperation MIN = new AggregationOperation() { + @Override + public Value perform(ValueList values) { + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null || nlist.isEmpty()) { + return ValueNull.getInstance(); + } + Value result = nlist.get(0); + for(Value v : nlist) { + if(((ValueBoolean)v.isLowerThan(result)).getValue()) { + result = v; + } + } + return result; + } + }; + + private static final AggregationOperation MAX = new AggregationOperation() { + @Override + public Value perform(ValueList values) { + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null || nlist.isEmpty()) { + return ValueNull.getInstance(); + } + Value result = nlist.get(0); + for(Value v : nlist) { + if(((ValueBoolean)v.isLowerThan(result)).negate().and(v.isEqual(result).negate()).getValue()) { + result = v; + } + } + return result; + } + }; + + private static final TransformOperation UNFOLD = new TransformOperation() { + @Override + public ValueList perform(ValueList values) { + if(!((TypeCollection)values.getType()).getElementType().isCollection()) { + throw new IllegalArgumentException("All elements must have a collection compatible type."); + } + ValueList nlist = Result.filterNullsList(values); + if(nlist.getValue() == null) { + return new ValueList(null, + ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType()); + } else if(nlist.isEmpty()) { + return new ValueList( + ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType()); + } + List<Value> ret = new ArrayList<Value>(); + for(Value v : nlist) { + if(v.getType().getPrimaryType() == Type.PrimaryType.SET) { + ret.addAll((ValueSet)v); + } else if(v.getType().getPrimaryType() == Type.PrimaryType.LIST) { + ret.addAll((ValueList)v); + } + } + return new ValueList(ret, + ((TypeCollection)((TypeCollection)values.getType()).getElementType()).getElementType()); + } + }; + + private static final TransformOperation DISTINCT = new TransformOperation() { + @Override + public ValueList perform(ValueList values) { + if(values.isEmpty()) + return new ValueList(((TypeCollection)values.getType()).getElementType()); + List<Value> ret = new ArrayList<Value>(); + for(Value v : values) { + if(!ret.contains(v)) { + ret.add(v); + } + } + return new ValueList(ret, ((TypeCollection)values.getType()).getElementType()); + } + }; + + private static final TransformOperation SORT = new TransformOperation() { + @Override + public ValueList perform(ValueList values) { + if(values.isEmpty()) + return new ValueList(((TypeCollection)values.getType()).getElementType()); + List<Value> ret = new ArrayList<Value>(); + ret.addAll(values); + Collections.sort(ret, new Comparator<Value>() { + public int compare(Value v1, Value v2) { + if(((ValueBoolean)v1.isLowerThan(v2)).getValue()) { + return -1; + } else if(((ValueBoolean)v1.isEqual(v2)).getValue()) { + return 0; + } else { + return 1; + } + } + }); + return new ValueList(ret, ((TypeCollection)values.getType()).getElementType()); + } + }; + + private final ValueTime EPOCH; + + private Functions() { + try { + EPOCH = new ValueTime("2000/01/01 00:00:00.000"); + } catch(ParseException exception) { + throw new InternalInterpreterException("Cannot parse time when creating an EPOCH object.\n" + + exception.getMessage()); + } + } + + public static Functions getInstance() { + if(instance == null) + instance = new Functions(); + return instance; + } + + public Result evaluate(String name, List<Result> arguments) { + switch(name) { + case "round": + if(arguments.size() == 1) + return arguments.get(0).unaryOperation(ROUND); + break; + case "floor": + if(arguments.size() == 1) + return arguments.get(0).unaryOperation(FLOOR); + break; + case "ceil": + if(arguments.size() == 1) + return arguments.get(0).unaryOperation(CEIL); + break; + case "now": + if(arguments.size() == 0) + return new ResultSingle(new ValueTime(Calendar.getInstance().getTimeInMillis())); + break; + case "epoch": + if(arguments.size() == 0) + return new ResultSingle(EPOCH); + break; + case "count": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(COUNT); + break; + case "size": + if(arguments.size() == 1) + return arguments.get(0).valueSize(); + break; + case "sum": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(SUM); + break; + case "avg": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(AVERAGE); + break; + case "land": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(AND); + break; + case "lor": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(OR); + break; + case "min": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(MIN); + break; + case "max": + if(arguments.size() == 1) + return arguments.get(0).aggregationOperation(MAX); + break; + case "unfold": + if(arguments.size() == 1) + return arguments.get(0).transformOperation(UNFOLD); + break; + case "distinct": + if(arguments.size() == 1) + return arguments.get(0).transformOperation(DISTINCT); + break; + case "sort": + if(arguments.size() == 1) + return arguments.get(0).transformOperation(SORT); + break; + case "filterNulls": + if(arguments.size() == 1) + return arguments.get(0).filterNulls(); + break; + case "first": + if(arguments.size() == 2) { + Value size = arguments.get(0).getValue(); + if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0) + return arguments.get(1).first(((ValueInt)size).getValue().intValue()); + throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER + + " and be >= 0."); + } + break; + case "last": + if(arguments.size() == 2) { + Value size = arguments.get(0).getValue(); + if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0) + return arguments.get(1).last(((ValueInt)size).getValue().intValue()); + throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER + + " and be >= 0."); + } + break; + case "random": + if(arguments.size() == 2) { + Value size = arguments.get(0).getValue(); + if(size.getType().isCompatible(TypePrimitive.INTEGER) && ((ValueInt)size).getValue().intValue() >= 0) + return arguments.get(1).random(((ValueInt)size).getValue().intValue()); + throw new IllegalArgumentException("First argument must have type " + TypePrimitive.INTEGER + + " and be >= 0."); + } + break; + case "to_boolean": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.BOOLEAN); + break; + case "to_contact": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.CONTACT); + break; + case "to_double": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.DOUBLE); + break; + case "to_duration": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.DURATION); + break; + case "to_integer": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.INTEGER); + break; + case "to_string": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.STRING); + break; + case "to_time": + if(arguments.size() == 1) + return arguments.get(0).convertTo(TypePrimitive.TIME); + break; + case "to_set": + if(arguments.size() == 1) { + Type t = arguments.get(0).getType(); + if(t.isCollection()) { + Type elementType = ((TypeCollection)t).getElementType(); + return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.SET, elementType)); + } + throw new IllegalArgumentException("First argument must be a collection."); + } + break; + case "to_list": + if(arguments.size() == 1) { + Type t = arguments.get(0).getType(); + if(t.isCollection()) { + Type elementType = ((TypeCollection)t).getElementType(); + return arguments.get(0).convertTo(new TypeCollection(Type.PrimaryType.LIST, elementType)); + } + throw new IllegalArgumentException("First argument must be a collection."); + } + break; + case "isNull": + if(arguments.size() == 1) + return arguments.get(0).isNull(); + break; + default: + throw new IllegalArgumentException("Illegal function name."); + } + throw new IllegalArgumentException("Illegal number of arguments."); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InsideQueryException.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InsideQueryException.java new file mode 100644 index 0000000..d591c35 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InsideQueryException.java @@ -0,0 +1,50 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +@SuppressWarnings("serial") +public class InsideQueryException extends InterpreterException { + private final String fragment; + private final Exception exception; + + protected InsideQueryException(String fragment, Exception exception) { + super(exception.getMessage() + "\nin: " + fragment); + this.fragment = fragment; + this.exception = exception; + } + + public String getFragment() { + return fragment; + } + + public Exception getException() { + return exception; + } + + @Override + public StackTraceElement[] getStackTrace() { + return exception.getStackTrace(); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InternalInterpreterException.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InternalInterpreterException.java new file mode 100644 index 0000000..8010df2 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InternalInterpreterException.java @@ -0,0 +1,32 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +@SuppressWarnings("serial") +public class InternalInterpreterException extends InterpreterException { + protected InternalInterpreterException(String message) { + super(message); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java new file mode 100644 index 0000000..4634459 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Interpreter.java @@ -0,0 +1,493 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; + +import pl.edu.mimuw.cloudatlas.interpreter.query.PrettyPrinter; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC; +import pl.edu.mimuw.cloudatlas.model.Attribute; +import pl.edu.mimuw.cloudatlas.model.TypePrimitive; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueBoolean; +import pl.edu.mimuw.cloudatlas.model.ValueDouble; +import pl.edu.mimuw.cloudatlas.model.ValueInt; +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 Environment(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 Environment(row1, table.getColumns()); + Result expr1 = orderItem.condexpr_.accept(new CondExprInterpreter(), env1); + Environment env2 = new Environment(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 = null; // TODO + Result result = selItem.condexpr_.accept(new CondExprInterpreter(), env); + return new QueryResult(result.getValue()); + } + + public QueryResult visit(AliasedSelItemC selItem, Table table) { + Environment env = null; // TODO + 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("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) { + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + + 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) { + return env.getIdent(expr.qident_); + } + + 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)); + + return Functions.getInstance().evaluate(expr.qident_, arguments); + } 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("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("Not yet implemented"); + } + + public Result visit(RelOpGeC op, ValuesPair pair) { + return pair.left.isLowerThan(pair.right).negate(); + } + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InterpreterException.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InterpreterException.java new file mode 100644 index 0000000..5dbe921 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InterpreterException.java @@ -0,0 +1,32 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +@SuppressWarnings("serial") +public abstract class InterpreterException extends RuntimeException { + protected InterpreterException(String message) { + super(message); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InvalidTypeException.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InvalidTypeException.java new file mode 100644 index 0000000..23a325f --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/InvalidTypeException.java @@ -0,0 +1,47 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import pl.edu.mimuw.cloudatlas.model.Type; + +@SuppressWarnings("serial") +public class InvalidTypeException extends InterpreterException { + private final Type expected; + private final Type got; + + protected InvalidTypeException(Type expected, Type got) { + super("Invalid type. Expected " + expected + ", got " + got + "."); + this.expected = expected; + this.got = got; + } + + public Type getExpected() { + return expected; + } + + public Type getGot() { + return got; + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Main.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Main.java new file mode 100644 index 0000000..a9857ed --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Main.java @@ -0,0 +1,247 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.io.ByteArrayInputStream; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.text.ParseException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Scanner; + +import pl.edu.mimuw.cloudatlas.interpreter.query.Yylex; +import pl.edu.mimuw.cloudatlas.interpreter.query.parser; +import pl.edu.mimuw.cloudatlas.model.PathName; +import pl.edu.mimuw.cloudatlas.model.TypePrimitive; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueBoolean; +import pl.edu.mimuw.cloudatlas.model.ValueContact; +import pl.edu.mimuw.cloudatlas.model.ValueDouble; +import pl.edu.mimuw.cloudatlas.model.ValueDuration; +import pl.edu.mimuw.cloudatlas.model.ValueInt; +import pl.edu.mimuw.cloudatlas.model.ValueList; +import pl.edu.mimuw.cloudatlas.model.ValueSet; +import pl.edu.mimuw.cloudatlas.model.ValueString; +import pl.edu.mimuw.cloudatlas.model.ValueTime; +import pl.edu.mimuw.cloudatlas.model.ZMI; + +public class Main { + private static ZMI root; + + public static void main(String[] args) throws Exception { + root = createTestHierarchy(); + Scanner scanner = new Scanner(System.in); + scanner.useDelimiter("\\n"); + while(scanner.hasNext()) + executeQueries(root, scanner.next()); + scanner.close(); + } + + private static PathName getPathName(ZMI zmi) { + String name = ((ValueString)zmi.getAttributes().get("name")).getValue(); + return zmi.getFather() == null? PathName.ROOT : getPathName(zmi.getFather()).levelDown(name); + } + + private static void executeQueries(ZMI zmi, String query) throws Exception { + if(!zmi.getSons().isEmpty()) { + for(ZMI son : zmi.getSons()) + executeQueries(son, query); + Interpreter interpreter = new Interpreter(zmi); + Yylex lex = new Yylex(new ByteArrayInputStream(query.getBytes())); + try { + List<QueryResult> result = interpreter.interpretProgram((new parser(lex)).pProgram()); + PathName zone = getPathName(zmi); + for(QueryResult r : result) { + System.out.println(zone + ": " + r); + zmi.getAttributes().addOrChange(r.getName(), r.getValue()); + } + } catch(InterpreterException exception) {} + } + } + + private static ValueContact createContact(String path, byte ip1, byte ip2, byte ip3, byte ip4) + throws UnknownHostException { + return new ValueContact(new PathName(path), InetAddress.getByAddress(new byte[] { + ip1, ip2, ip3, ip4 + })); + } + + private static ZMI createTestHierarchy() throws ParseException, UnknownHostException { + ValueContact violet07Contact = createContact("/uw/violet07", (byte)10, (byte)1, (byte)1, (byte)10); + ValueContact khaki13Contact = createContact("/uw/khaki13", (byte)10, (byte)1, (byte)1, (byte)38); + ValueContact khaki31Contact = createContact("/uw/khaki31", (byte)10, (byte)1, (byte)1, (byte)39); + ValueContact whatever01Contact = createContact("/uw/whatever01", (byte)82, (byte)111, (byte)52, (byte)56); + ValueContact whatever02Contact = createContact("/uw/whatever02", (byte)82, (byte)111, (byte)52, (byte)57); + + List<Value> list; + + root = new ZMI(); + root.getAttributes().add("level", new ValueInt(0l)); + root.getAttributes().add("name", new ValueString(null)); + root.getAttributes().add("owner", new ValueString("/uw/violet07")); + root.getAttributes().add("timestamp", new ValueTime("2012/11/09 20:10:17.342")); + root.getAttributes().add("contacts", new ValueSet(TypePrimitive.CONTACT)); + root.getAttributes().add("cardinality", new ValueInt(0l)); + + ZMI uw = new ZMI(root); + root.addSon(uw); + uw.getAttributes().add("level", new ValueInt(1l)); + uw.getAttributes().add("name", new ValueString("uw")); + uw.getAttributes().add("owner", new ValueString("/uw/violet07")); + uw.getAttributes().add("timestamp", new ValueTime("2012/11/09 20:8:13.123")); + uw.getAttributes().add("contacts", new ValueSet(TypePrimitive.CONTACT)); + uw.getAttributes().add("cardinality", new ValueInt(0l)); + + ZMI pjwstk = new ZMI(root); + root.addSon(pjwstk); + pjwstk.getAttributes().add("level", new ValueInt(1l)); + pjwstk.getAttributes().add("name", new ValueString("pjwstk")); + pjwstk.getAttributes().add("owner", new ValueString("/pjwstk/whatever01")); + pjwstk.getAttributes().add("timestamp", new ValueTime("2012/11/09 20:8:13.123")); + pjwstk.getAttributes().add("contacts", new ValueSet(TypePrimitive.CONTACT)); + pjwstk.getAttributes().add("cardinality", new ValueInt(0l)); + + ZMI violet07 = new ZMI(uw); + uw.addSon(violet07); + violet07.getAttributes().add("level", new ValueInt(2l)); + violet07.getAttributes().add("name", new ValueString("violet07")); + violet07.getAttributes().add("owner", new ValueString("/uw/violet07")); + violet07.getAttributes().add("timestamp", new ValueTime("2012/11/09 18:00:00.000")); + list = Arrays.asList(new Value[] { + khaki31Contact, whatever01Contact + }); + violet07.getAttributes().add("contacts", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + violet07.getAttributes().add("cardinality", new ValueInt(1l)); + list = Arrays.asList(new Value[] { + violet07Contact, + }); + violet07.getAttributes().add("members", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + violet07.getAttributes().add("creation", new ValueTime("2011/11/09 20:8:13.123")); + violet07.getAttributes().add("cpu_usage", new ValueDouble(0.9)); + violet07.getAttributes().add("num_cores", new ValueInt(3l)); + violet07.getAttributes().add("has_ups", new ValueBoolean(null)); + list = Arrays.asList(new Value[] { + new ValueString("tola"), new ValueString("tosia"), + }); + violet07.getAttributes().add("some_names", new ValueList(list, TypePrimitive.STRING)); + violet07.getAttributes().add("expiry", new ValueDuration(13l, 12l, 0l, 0l, 0l)); + + ZMI khaki31 = new ZMI(uw); + uw.addSon(khaki31); + khaki31.getAttributes().add("level", new ValueInt(2l)); + khaki31.getAttributes().add("name", new ValueString("khaki31")); + khaki31.getAttributes().add("owner", new ValueString("/uw/khaki31")); + khaki31.getAttributes().add("timestamp", new ValueTime("2012/11/09 20:03:00.000")); + list = Arrays.asList(new Value[] { + violet07Contact, whatever02Contact, + }); + khaki31.getAttributes().add("contacts", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + khaki31.getAttributes().add("cardinality", new ValueInt(1l)); + list = Arrays.asList(new Value[] { + khaki31Contact + }); + khaki31.getAttributes().add("members", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + khaki31.getAttributes().add("creation", new ValueTime("2011/11/09 20:12:13.123")); + khaki31.getAttributes().add("cpu_usage", new ValueDouble(null)); + khaki31.getAttributes().add("num_cores", new ValueInt(3l)); + khaki31.getAttributes().add("has_ups", new ValueBoolean(false)); + list = Arrays.asList(new Value[] { + new ValueString("agatka"), new ValueString("beatka"), new ValueString("celina"), + }); + khaki31.getAttributes().add("some_names", new ValueList(list, TypePrimitive.STRING)); + khaki31.getAttributes().add("expiry", new ValueDuration(-13l, -11l, 0l, 0l, 0l)); + + ZMI khaki13 = new ZMI(uw); + uw.addSon(khaki13); + khaki13.getAttributes().add("level", new ValueInt(2l)); + khaki13.getAttributes().add("name", new ValueString("khaki13")); + khaki13.getAttributes().add("owner", new ValueString("/uw/khaki13")); + khaki13.getAttributes().add("timestamp", new ValueTime("2012/11/09 21:03:00.000")); + list = Arrays.asList(new Value[] {}); + khaki13.getAttributes().add("contacts", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + khaki13.getAttributes().add("cardinality", new ValueInt(1l)); + list = Arrays.asList(new Value[] { + khaki13Contact, + }); + khaki13.getAttributes().add("members", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + khaki13.getAttributes().add("creation", new ValueTime((Long)null)); + khaki13.getAttributes().add("cpu_usage", new ValueDouble(0.1)); + khaki13.getAttributes().add("num_cores", new ValueInt(null)); + khaki13.getAttributes().add("has_ups", new ValueBoolean(true)); + list = Arrays.asList(new Value[] {}); + khaki13.getAttributes().add("some_names", new ValueList(list, TypePrimitive.STRING)); + khaki13.getAttributes().add("expiry", new ValueDuration((Long)null)); + + ZMI whatever01 = new ZMI(pjwstk); + pjwstk.addSon(whatever01); + whatever01.getAttributes().add("level", new ValueInt(2l)); + whatever01.getAttributes().add("name", new ValueString("whatever01")); + whatever01.getAttributes().add("owner", new ValueString("/uw/whatever01")); + whatever01.getAttributes().add("timestamp", new ValueTime("2012/11/09 21:12:00.000")); + list = Arrays.asList(new Value[] { + violet07Contact, whatever02Contact, + }); + whatever01.getAttributes().add("contacts", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + whatever01.getAttributes().add("cardinality", new ValueInt(1l)); + list = Arrays.asList(new Value[] { + whatever01Contact, + }); + whatever01.getAttributes().add("members", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + whatever01.getAttributes().add("creation", new ValueTime("2012/10/18 07:03:00.000")); + whatever01.getAttributes().add("cpu_usage", new ValueDouble(0.1)); + whatever01.getAttributes().add("num_cores", new ValueInt(7l)); + list = Arrays.asList(new Value[] { + new ValueString("rewrite") + }); + whatever01.getAttributes().add("php_modules", new ValueList(list, TypePrimitive.STRING)); + + ZMI whatever02 = new ZMI(pjwstk); + pjwstk.addSon(whatever02); + whatever02.getAttributes().add("level", new ValueInt(2l)); + whatever02.getAttributes().add("name", new ValueString("whatever02")); + whatever02.getAttributes().add("owner", new ValueString("/uw/whatever02")); + whatever02.getAttributes().add("timestamp", new ValueTime("2012/11/09 21:13:00.000")); + list = Arrays.asList(new Value[] { + khaki31Contact, whatever01Contact, + }); + whatever02.getAttributes().add("contacts", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + whatever02.getAttributes().add("cardinality", new ValueInt(1l)); + list = Arrays.asList(new Value[] { + whatever02Contact, + }); + whatever02.getAttributes().add("members", new ValueSet(new HashSet<Value>(list), TypePrimitive.CONTACT)); + whatever02.getAttributes().add("creation", new ValueTime("2012/10/18 07:04:00.000")); + whatever02.getAttributes().add("cpu_usage", new ValueDouble(0.4)); + whatever02.getAttributes().add("num_cores", new ValueInt(13l)); + list = Arrays.asList(new Value[] { + new ValueString("odbc") + }); + whatever02.getAttributes().add("php_modules", new ValueList(list, TypePrimitive.STRING)); + + return root; + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/NoSuchAttributeException.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/NoSuchAttributeException.java new file mode 100644 index 0000000..b85438c --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/NoSuchAttributeException.java @@ -0,0 +1,39 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +@SuppressWarnings("serial") +public class NoSuchAttributeException extends InterpreterException { + private final String attribute; + + protected NoSuchAttributeException(String attribute) { + super("Attribute " + attribute + " does not exist."); + this.attribute = attribute; + } + + public String getAttribute() { + return attribute; + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/QueryResult.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/QueryResult.java new file mode 100644 index 0000000..2fc0cce --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/QueryResult.java @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import pl.edu.mimuw.cloudatlas.model.Attribute; +import pl.edu.mimuw.cloudatlas.model.Value; + +// immutable +public class QueryResult { + private final Attribute name; + private final Value value; + + public QueryResult(Attribute name, Value value) { + this.name = name; + this.value = value; + } + + public QueryResult(Value value) { + this(null, value); + } + + public Attribute getName() { + return name; + } + + public Value getValue() { + return value; + } + + public String toString() { + return name + ": " + value; + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Result.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Result.java new file mode 100644 index 0000000..5afbe65 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Result.java @@ -0,0 +1,265 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import pl.edu.mimuw.cloudatlas.model.Type; +import pl.edu.mimuw.cloudatlas.model.TypeCollection; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueList; + +abstract class Result { + public interface BinaryOperation { + public Value perform(Value v1, Value v2); + } + + public interface UnaryOperation { + public Value perform(Value v); + } + + public interface AggregationOperation { + public Value perform(ValueList values); + } + + public interface TransformOperation { + public ValueList perform(ValueList values); + } + + private static final BinaryOperation IS_EQUAL = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.isEqual(v2); + } + }; + + private static final BinaryOperation IS_LOWER_THAN = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.isLowerThan(v2); + } + }; + + private static final BinaryOperation ADD_VALUE = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.addValue(v2); + } + }; + + private static final BinaryOperation SUBTRACT = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.subtract(v2); + } + }; + + private static final BinaryOperation MULTIPLY = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.multiply(v2); + } + }; + + private static final BinaryOperation DIVIDE = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.divide(v2); + } + }; + + private static final BinaryOperation MODULO = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.modulo(v2); + } + }; + + private static final BinaryOperation AND = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.and(v2); + } + }; + + private static final BinaryOperation OR = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.or(v2); + } + }; + + private static final BinaryOperation REG_EXPR = new BinaryOperation() { + @Override + public Value perform(Value v1, Value v2) { + return v1.regExpr(v2); + } + }; + + private static final UnaryOperation NEGATE = new UnaryOperation() { + @Override + public Value perform(Value v) { + return v.negate(); + } + }; + + private static final UnaryOperation VALUE_SIZE = new UnaryOperation() { + @Override + public Value perform(Value v) { + return v.valueSize(); + } + }; + + protected abstract Result binaryOperationTyped(BinaryOperation operation, ResultSingle right); + + public Result binaryOperation(BinaryOperation operation, Result right) { + return right.callMe(operation, this); + } + + public abstract Result unaryOperation(UnaryOperation operation); + + protected abstract Result callMe(BinaryOperation operation, Result left); + + public abstract Value getValue(); + + public abstract ValueList getList(); + + public abstract ValueList getColumn(); + + public ResultSingle aggregationOperation(AggregationOperation operation) { + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + + public Result transformOperation(TransformOperation operation) { + // TODO + throw new UnsupportedOperationException("Not yet implemented"); + } + + public Result isEqual(Result right) { + return right.callMe(IS_EQUAL, this); + } + + public Result isLowerThan(Result right) { + return right.callMe(IS_LOWER_THAN, this); + } + + public Result addValue(Result right) { + return right.callMe(ADD_VALUE, this); + } + + public Result subtract(Result right) { + return right.callMe(SUBTRACT, this); + } + + public Result multiply(Result right) { + return right.callMe(MULTIPLY, this); + } + + public Result divide(Result right) { + return right.callMe(DIVIDE, this); + } + + public Result modulo(Result right) { + return right.callMe(MODULO, this); + } + + public Result and(Result right) { + return right.callMe(AND, this); + } + + public Result or(Result right) { + return right.callMe(OR, this); + } + + public Result regExpr(Result right) { + return right.callMe(REG_EXPR, this); + } + + public Result negate() { + return unaryOperation(NEGATE); + } + + public Result valueSize() { + return unaryOperation(VALUE_SIZE); + } + + protected static ValueList filterNullsList(ValueList list) { + List<Value> result = new ArrayList<Value>(); + if(list.isEmpty()) + return new ValueList(result, ((TypeCollection)list.getType()).getElementType()); + for(Value v : list) + if(!v.isNull()) + result.add(v); + return new ValueList(result.isEmpty()? null : result, ((TypeCollection)list.getType()).getElementType()); + } + + public abstract Result filterNulls(); + + protected static ValueList firstList(ValueList list, int size) { + ValueList nlist = filterNullsList(list); + if(nlist.getValue() == null) + return nlist; + List<Value> result = new ArrayList<Value>(size); + int i = 0; + for(Value v : nlist) { + result.add(v); + if(++i == size) + break; + } + return new ValueList(result, ((TypeCollection)list.getType()).getElementType()); + } + + public abstract Result first(int size); + + protected static ValueList lastList(ValueList list, int size) { + ValueList nlist = filterNullsList(list); + if(nlist.getValue() == null) + return nlist; + List<Value> result = new ArrayList<Value>(size); + for(int i = Math.max(0, list.size() - size); i < list.size(); ++i) + result.add(list.get(i)); + return new ValueList(result, ((TypeCollection)list.getType()).getElementType()); + } + + public abstract Result last(int size); + + protected static ValueList randomList(ValueList list, int size) { + ValueList nlist = filterNullsList(list); + if(nlist.getValue() == null || list.size() <= size) + return nlist; + Collections.shuffle(nlist); + return new ValueList(nlist.getValue().subList(0, size), ((TypeCollection)list.getType()).getElementType()); + } + + public abstract Result random(int size); + + public abstract Result convertTo(Type to); + + public abstract ResultSingle isNull(); + + public abstract Type getType(); +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/ResultSingle.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/ResultSingle.java new file mode 100644 index 0000000..ada8f93 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/ResultSingle.java @@ -0,0 +1,103 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import pl.edu.mimuw.cloudatlas.model.Type; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueBoolean; +import pl.edu.mimuw.cloudatlas.model.ValueList; + +class ResultSingle extends Result { + private final Value value; + + public ResultSingle(Value value) { + this.value = value; + } + + @Override + protected ResultSingle binaryOperationTyped(BinaryOperation operation, ResultSingle right) { + return new ResultSingle(operation.perform(value, right.value)); + } + + @Override + public ResultSingle unaryOperation(UnaryOperation operation) { + return new ResultSingle(operation.perform(value)); + } + + @Override + protected Result callMe(BinaryOperation operation, Result left) { + return left.binaryOperationTyped(operation, this); + } + + @Override + public Value getValue() { + return value; + } + + @Override + public ValueList getList() { + throw new UnsupportedOperationException("Not a ResultList."); + } + + @Override + public ValueList getColumn() { + throw new UnsupportedOperationException("Not a ResultColumn."); + } + + @Override + public Result filterNulls() { + throw new UnsupportedOperationException("Operation filterNulls not supported on ResultSingle."); + } + + @Override + public Result first(int size) { + throw new UnsupportedOperationException("Operation first not supported on ResultSingle."); + } + + @Override + public Result last(int size) { + throw new UnsupportedOperationException("Operation last not supported on ResultSingle."); + } + + @Override + public Result random(int size) { + throw new UnsupportedOperationException("Operation random not supported on ResultSingle."); + } + + @Override + public ResultSingle convertTo(Type to) { + return new ResultSingle(value.convertTo(to)); + } + + @Override + public ResultSingle isNull() { + return new ResultSingle(new ValueBoolean(value.isNull())); + } + + @Override + public Type getType() { + return value.getType(); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Table.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Table.java new file mode 100644 index 0000000..9f2e1d9 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/Table.java @@ -0,0 +1,123 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.Map.Entry; + +import pl.edu.mimuw.cloudatlas.model.Attribute; +import pl.edu.mimuw.cloudatlas.model.Type; +import pl.edu.mimuw.cloudatlas.model.TypeCollection; +import pl.edu.mimuw.cloudatlas.model.Value; +import pl.edu.mimuw.cloudatlas.model.ValueList; +import pl.edu.mimuw.cloudatlas.model.ValueNull; +import pl.edu.mimuw.cloudatlas.model.ZMI; + +public class Table implements Iterable<TableRow> { + private final List<String> columns = new ArrayList<String>(); + private final Map<String, Integer> headersMap = new HashMap<String, Integer>(); + private final List<TableRow> rows = new ArrayList<TableRow>(); + + // creates whole table based on a given ZMI + public Table(ZMI zmi) { + Set<String> allColumns = new HashSet<String>(); + for(ZMI z : zmi.getSons()) + for(Entry<Attribute, Value> e : z.getAttributes()) + allColumns.add(e.getKey().getName()); + + columns.addAll(allColumns); + int i = 0; + for(String c : columns) + headersMap.put(c, i++); + for(ZMI z : zmi.getSons()) { + Value[] row = new Value[columns.size()]; + for(int j = 0; j < row.length; ++j) + row[j] = ValueNull.getInstance(); + for(Entry<Attribute, Value> e : z.getAttributes()) + row[getColumnIndex(e.getKey().getName())] = e.getValue(); + appendRow(new TableRow(row)); + } + } + + // creates an empty table with same columns as given + public Table(Table table) { + this.columns.addAll(table.columns); + this.headersMap.putAll(table.headersMap); + } + + public List<String> getColumns() { + return Collections.unmodifiableList(columns); + } + + public void appendRow(TableRow row) { + if(row.getSize() != columns.size()) + throw new InternalInterpreterException("Cannot append row. Length expected: " + columns.size() + ", got: " + + row.getSize() + "."); + rows.add(row); + } + + public int getColumnIndex(String column) { + try { + return headersMap.get(column).intValue(); + } catch(NullPointerException exception) { + throw new NoSuchAttributeException(column); + } + } + + public ValueList getColumn(String column) { + if(column.startsWith("&")) { + throw new NoSuchAttributeException(column); + } + try { + int position = headersMap.get(column); + List<Value> result = new ArrayList<Value>(); + for(TableRow row : rows) { + Value v = row.getIth(position); + result.add(v); + } + Type elementType = TypeCollection.computeElementType(result); + return new ValueList(result, elementType); + } catch(NullPointerException exception) { + throw new NoSuchAttributeException(column); + } + } + + @Override + public Iterator<TableRow> iterator() { + return rows.iterator(); + } + + public void sort(Comparator<TableRow> comparator) { + Collections.sort(rows, comparator); + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/TableRow.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/TableRow.java new file mode 100644 index 0000000..23fd2dd --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/TableRow.java @@ -0,0 +1,46 @@ +/** + * Copyright (c) 2014, University of Warsaw + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other materials provided + * with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package pl.edu.mimuw.cloudatlas.interpreter; + +import java.util.Arrays; + +import pl.edu.mimuw.cloudatlas.model.Value; + +// immutable +public class TableRow { + private final Value[] columns; + + public TableRow(Value[] values) { + this.columns = Arrays.copyOf(values, values.length); + } + + public int getSize() { + return columns.length; + } + + public Value getIth(int i) { + return columns[i]; + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AliasedSelItemC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AliasedSelItemC.java new file mode 100644 index 0000000..f1f1b5a --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AliasedSelItemC.java @@ -0,0 +1,25 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class AliasedSelItemC extends SelItem { + public final CondExpr condexpr_; + public final String qident_; + + public AliasedSelItemC(CondExpr p1, String p2) { condexpr_ = p1; qident_ = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC)o; + return this.condexpr_.equals(x.condexpr_) && this.qident_.equals(x.qident_); + } + return false; + } + + public int hashCode() { + return 37*(this.condexpr_.hashCode())+this.qident_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AscOrderC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AscOrderC.java new file mode 100644 index 0000000..80163bb --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/AscOrderC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class AscOrderC extends Order { + + public AscOrderC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExpr.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExpr.java new file mode 100644 index 0000000..c098b14 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExpr.java @@ -0,0 +1,23 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class BasicExpr implements java.io.Serializable { + public abstract <R,A> R accept(BasicExpr.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprAddC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprAddC.java new file mode 100644 index 0000000..754839a --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprAddC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprAddC extends BasicExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + + public BasicExprAddC(BasicExpr p1, BasicExpr p2) { basicexpr_1 = p1; basicexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_1.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprDivC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprDivC.java new file mode 100644 index 0000000..8abd22a --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprDivC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprDivC extends BasicExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + + public BasicExprDivC(BasicExpr p1, BasicExpr p2) { basicexpr_1 = p1; basicexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_1.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprModC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprModC.java new file mode 100644 index 0000000..db90b89 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprModC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprModC extends BasicExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + + public BasicExprModC(BasicExpr p1, BasicExpr p2) { basicexpr_1 = p1; basicexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_1.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprMulC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprMulC.java new file mode 100644 index 0000000..369c545 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprMulC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprMulC extends BasicExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + + public BasicExprMulC(BasicExpr p1, BasicExpr p2) { basicexpr_1 = p1; basicexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_1.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprNegC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprNegC.java new file mode 100644 index 0000000..6abb7c4 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprNegC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprNegC extends BasicExpr { + public final BasicExpr basicexpr_; + + public BasicExprNegC(BasicExpr p1) { basicexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC)o; + return this.basicexpr_.equals(x.basicexpr_); + } + return false; + } + + public int hashCode() { + return this.basicexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprSubC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprSubC.java new file mode 100644 index 0000000..7f3bc58 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BasicExprSubC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BasicExprSubC extends BasicExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + + public BasicExprSubC(BasicExpr p1, BasicExpr p2) { basicexpr_1 = p1; basicexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_1.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExpr.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExpr.java new file mode 100644 index 0000000..b470b34 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExpr.java @@ -0,0 +1,12 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class BoolExpr implements java.io.Serializable { + public abstract <R,A> R accept(BoolExpr.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprBasicExprC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprBasicExprC.java new file mode 100644 index 0000000..eb08bcf --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprBasicExprC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BoolExprBasicExprC extends BoolExpr { + public final BasicExpr basicexpr_; + + public BoolExprBasicExprC(BasicExpr p1) { basicexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC)o; + return this.basicexpr_.equals(x.basicexpr_); + } + return false; + } + + public int hashCode() { + return this.basicexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprCmpC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprCmpC.java new file mode 100644 index 0000000..f8a2f21 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprCmpC.java @@ -0,0 +1,25 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BoolExprCmpC extends BoolExpr { + public final BasicExpr basicexpr_1, basicexpr_2; + public final RelOp relop_; + + public BoolExprCmpC(BasicExpr p1, RelOp p2, BasicExpr p3) { basicexpr_1 = p1; relop_ = p2; basicexpr_2 = p3; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC)o; + return this.basicexpr_1.equals(x.basicexpr_1) && this.relop_.equals(x.relop_) && this.basicexpr_2.equals(x.basicexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(37*(this.basicexpr_1.hashCode())+this.relop_.hashCode())+this.basicexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprRegExpC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprRegExpC.java new file mode 100644 index 0000000..31af2d2 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/BoolExprRegExpC.java @@ -0,0 +1,25 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class BoolExprRegExpC extends BoolExpr { + public final BasicExpr basicexpr_; + public final String string_; + + public BoolExprRegExpC(BasicExpr p1, String p2) { basicexpr_ = p1; string_ = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC)o; + return this.basicexpr_.equals(x.basicexpr_) && this.string_.equals(x.string_); + } + return false; + } + + public int hashCode() { + return 37*(this.basicexpr_.hashCode())+this.string_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExpr.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExpr.java new file mode 100644 index 0000000..73136e7 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExpr.java @@ -0,0 +1,13 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class CondExpr implements java.io.Serializable { + public abstract <R,A> R accept(CondExpr.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprAndC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprAndC.java new file mode 100644 index 0000000..094affb --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprAndC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class CondExprAndC extends CondExpr { + public final CondExpr condexpr_1, condexpr_2; + + public CondExprAndC(CondExpr p1, CondExpr p2) { condexpr_1 = p1; condexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC)o; + return this.condexpr_1.equals(x.condexpr_1) && this.condexpr_2.equals(x.condexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.condexpr_1.hashCode())+this.condexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprBoolExprC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprBoolExprC.java new file mode 100644 index 0000000..d102a29 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprBoolExprC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class CondExprBoolExprC extends CondExpr { + public final BoolExpr boolexpr_; + + public CondExprBoolExprC(BoolExpr p1) { boolexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC)o; + return this.boolexpr_.equals(x.boolexpr_); + } + return false; + } + + public int hashCode() { + return this.boolexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprNotC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprNotC.java new file mode 100644 index 0000000..1e84219 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprNotC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class CondExprNotC extends CondExpr { + public final CondExpr condexpr_; + + public CondExprNotC(CondExpr p1) { condexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC)o; + return this.condexpr_.equals(x.condexpr_); + } + return false; + } + + public int hashCode() { + return this.condexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprOrC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprOrC.java new file mode 100644 index 0000000..08e7484 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/CondExprOrC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class CondExprOrC extends CondExpr { + public final CondExpr condexpr_1, condexpr_2; + + public CondExprOrC(CondExpr p1, CondExpr p2) { condexpr_1 = p1; condexpr_2 = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC)o; + return this.condexpr_1.equals(x.condexpr_1) && this.condexpr_2.equals(x.condexpr_2); + } + return false; + } + + public int hashCode() { + return 37*(this.condexpr_1.hashCode())+this.condexpr_2.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/DescOrderC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/DescOrderC.java new file mode 100644 index 0000000..a08cc61 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/DescOrderC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class DescOrderC extends Order { + + public DescOrderC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EBoolC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EBoolC.java new file mode 100644 index 0000000..da55dd5 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EBoolC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EBoolC extends BasicExpr { + public final String qbool_; + + public EBoolC(String p1) { qbool_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC)o; + return this.qbool_.equals(x.qbool_); + } + return false; + } + + public int hashCode() { + return this.qbool_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ECondExprC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ECondExprC.java new file mode 100644 index 0000000..db4e9f1 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ECondExprC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ECondExprC extends BasicExpr { + public final CondExpr condexpr_; + + public ECondExprC(CondExpr p1) { condexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC)o; + return this.condexpr_.equals(x.condexpr_); + } + return false; + } + + public int hashCode() { + return this.condexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EDblC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EDblC.java new file mode 100644 index 0000000..f07e616 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EDblC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EDblC extends BasicExpr { + public final String qdouble_; + + public EDblC(String p1) { qdouble_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC)o; + return this.qdouble_.equals(x.qdouble_); + } + return false; + } + + public int hashCode() { + return this.qdouble_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EFunC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EFunC.java new file mode 100644 index 0000000..93af7e9 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EFunC.java @@ -0,0 +1,25 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EFunC extends BasicExpr { + public final String qident_; + public final ListCondExpr listcondexpr_; + + public EFunC(String p1, ListCondExpr p2) { qident_ = p1; listcondexpr_ = p2; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC)o; + return this.qident_.equals(x.qident_) && this.listcondexpr_.equals(x.listcondexpr_); + } + return false; + } + + public int hashCode() { + return 37*(this.qident_.hashCode())+this.listcondexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIdentC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIdentC.java new file mode 100644 index 0000000..7c4119d --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIdentC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EIdentC extends BasicExpr { + public final String qident_; + + public EIdentC(String p1) { qident_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC)o; + return this.qident_.equals(x.qident_); + } + return false; + } + + public int hashCode() { + return this.qident_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIntC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIntC.java new file mode 100644 index 0000000..069ecdb --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EIntC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EIntC extends BasicExpr { + public final String qinteger_; + + public EIntC(String p1) { qinteger_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC)o; + return this.qinteger_.equals(x.qinteger_); + } + return false; + } + + public int hashCode() { + return this.qinteger_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStmtC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStmtC.java new file mode 100644 index 0000000..4157f1e --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStmtC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EStmtC extends BasicExpr { + public final Statement statement_; + + public EStmtC(Statement p1) { statement_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC)o; + return this.statement_.equals(x.statement_); + } + return false; + } + + public int hashCode() { + return this.statement_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStrC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStrC.java new file mode 100644 index 0000000..3bf4a75 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/EStrC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class EStrC extends BasicExpr { + public final String string_; + + public EStrC(String p1) { string_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC)o; + return this.string_.equals(x.string_); + } + return false; + } + + public int hashCode() { + return this.string_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListCondExpr.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListCondExpr.java new file mode 100644 index 0000000..929ff07 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListCondExpr.java @@ -0,0 +1,4 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ListCondExpr extends java.util.LinkedList<CondExpr> { +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListOrderItem.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListOrderItem.java new file mode 100644 index 0000000..47ba4a8 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListOrderItem.java @@ -0,0 +1,4 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ListOrderItem extends java.util.LinkedList<OrderItem> { +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListSelItem.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListSelItem.java new file mode 100644 index 0000000..5392851 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListSelItem.java @@ -0,0 +1,4 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ListSelItem extends java.util.LinkedList<SelItem> { +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListStatement.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListStatement.java new file mode 100644 index 0000000..fa5070a --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ListStatement.java @@ -0,0 +1,4 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ListStatement extends java.util.LinkedList<Statement> { +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoNullsC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoNullsC.java new file mode 100644 index 0000000..c7f54c9 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoNullsC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NoNullsC extends Nulls { + + public NoNullsC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderByC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderByC.java new file mode 100644 index 0000000..d357bcd --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderByC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NoOrderByC extends OrderBy { + + public NoOrderByC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderC.java new file mode 100644 index 0000000..0888840 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoOrderC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NoOrderC extends Order { + + public NoOrderC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoWhereC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoWhereC.java new file mode 100644 index 0000000..725fe03 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NoWhereC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NoWhereC extends Where { + + public NoWhereC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullFirstsC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullFirstsC.java new file mode 100644 index 0000000..fa837b1 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullFirstsC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NullFirstsC extends Nulls { + + public NullFirstsC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Nulls.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Nulls.java new file mode 100644 index 0000000..fbd153b --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Nulls.java @@ -0,0 +1,12 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class Nulls implements java.io.Serializable { + public abstract <R,A> R accept(Nulls.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullsLastC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullsLastC.java new file mode 100644 index 0000000..fcf0e74 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/NullsLastC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class NullsLastC extends Nulls { + + public NullsLastC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Order.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Order.java new file mode 100644 index 0000000..bd7094c --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Order.java @@ -0,0 +1,12 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class Order implements java.io.Serializable { + public abstract <R,A> R accept(Order.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderBy.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderBy.java new file mode 100644 index 0000000..c136dc4 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderBy.java @@ -0,0 +1,11 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class OrderBy implements java.io.Serializable { + public abstract <R,A> R accept(OrderBy.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderByC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderByC.java new file mode 100644 index 0000000..e599401 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderByC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class OrderByC extends OrderBy { + public final ListOrderItem listorderitem_; + + public OrderByC(ListOrderItem p1) { listorderitem_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC)o; + return this.listorderitem_.equals(x.listorderitem_); + } + return false; + } + + public int hashCode() { + return this.listorderitem_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItem.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItem.java new file mode 100644 index 0000000..3ea76ff --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItem.java @@ -0,0 +1,10 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class OrderItem implements java.io.Serializable { + public abstract <R,A> R accept(OrderItem.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItemC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItemC.java new file mode 100644 index 0000000..2d6228b --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/OrderItemC.java @@ -0,0 +1,26 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class OrderItemC extends OrderItem { + public final CondExpr condexpr_; + public final Order order_; + public final Nulls nulls_; + + public OrderItemC(CondExpr p1, Order p2, Nulls p3) { condexpr_ = p1; order_ = p2; nulls_ = p3; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC)o; + return this.condexpr_.equals(x.condexpr_) && this.order_.equals(x.order_) && this.nulls_.equals(x.nulls_); + } + return false; + } + + public int hashCode() { + return 37*(37*(this.condexpr_.hashCode())+this.order_.hashCode())+this.nulls_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Program.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Program.java new file mode 100644 index 0000000..4332025 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Program.java @@ -0,0 +1,10 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class Program implements java.io.Serializable { + public abstract <R,A> R accept(Program.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ProgramC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ProgramC.java new file mode 100644 index 0000000..6b7e999 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/ProgramC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class ProgramC extends Program { + public final ListStatement liststatement_; + + public ProgramC(ListStatement p1) { liststatement_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC)o; + return this.liststatement_.equals(x.liststatement_); + } + return false; + } + + public int hashCode() { + return this.liststatement_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOp.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOp.java new file mode 100644 index 0000000..f35b2dd --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOp.java @@ -0,0 +1,15 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class RelOp implements java.io.Serializable { + public abstract <R,A> R accept(RelOp.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpEqC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpEqC.java new file mode 100644 index 0000000..f0fe3a2 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpEqC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpEqC extends RelOp { + + public RelOpEqC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGeC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGeC.java new file mode 100644 index 0000000..e0498bc --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGeC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpGeC extends RelOp { + + public RelOpGeC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGtC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGtC.java new file mode 100644 index 0000000..45c10b6 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpGtC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpGtC extends RelOp { + + public RelOpGtC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLeC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLeC.java new file mode 100644 index 0000000..a0de97a --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLeC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpLeC extends RelOp { + + public RelOpLeC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLtC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLtC.java new file mode 100644 index 0000000..0407ab6 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpLtC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpLtC extends RelOp { + + public RelOpLtC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpNeC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpNeC.java new file mode 100644 index 0000000..fc19670 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/RelOpNeC.java @@ -0,0 +1,22 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class RelOpNeC extends RelOp { + + public RelOpNeC() { } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC) { + return true; + } + return false; + } + + public int hashCode() { + return 37; + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItem.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItem.java new file mode 100644 index 0000000..d1c5552 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItem.java @@ -0,0 +1,11 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class SelItem implements java.io.Serializable { + public abstract <R,A> R accept(SelItem.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItemC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItemC.java new file mode 100644 index 0000000..f8fc8a4 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/SelItemC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class SelItemC extends SelItem { + public final CondExpr condexpr_; + + public SelItemC(CondExpr p1) { condexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC)o; + return this.condexpr_.equals(x.condexpr_); + } + return false; + } + + public int hashCode() { + return this.condexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Statement.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Statement.java new file mode 100644 index 0000000..8f6e252 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Statement.java @@ -0,0 +1,10 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class Statement implements java.io.Serializable { + public abstract <R,A> R accept(Statement.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/StatementC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/StatementC.java new file mode 100644 index 0000000..fd097fd --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/StatementC.java @@ -0,0 +1,26 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class StatementC extends Statement { + public final ListSelItem listselitem_; + public final Where where_; + public final OrderBy orderby_; + + public StatementC(ListSelItem p1, Where p2, OrderBy p3) { listselitem_ = p1; where_ = p2; orderby_ = p3; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC)o; + return this.listselitem_.equals(x.listselitem_) && this.where_.equals(x.where_) && this.orderby_.equals(x.orderby_); + } + return false; + } + + public int hashCode() { + return 37*(37*(this.listselitem_.hashCode())+this.where_.hashCode())+this.orderby_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Where.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Where.java new file mode 100644 index 0000000..0c21d98 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/Where.java @@ -0,0 +1,11 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public abstract class Where implements java.io.Serializable { + public abstract <R,A> R accept(Where.Visitor<R,A> v, A arg); + public interface Visitor <R,A> { + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC p, A arg); + public R visit(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC p, A arg); + + } + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/WhereC.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/WhereC.java new file mode 100644 index 0000000..c068881 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Absyn/WhereC.java @@ -0,0 +1,24 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query.Absyn; // Java Package generated by the BNF Converter. + +public class WhereC extends Where { + public final CondExpr condexpr_; + + public WhereC(CondExpr p1) { condexpr_ = p1; } + + public <R,A> R accept(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where.Visitor<R,A> v, A arg) { return v.visit(this, arg); } + + public boolean equals(Object o) { + if (this == o) return true; + if (o instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC) { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC x = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC)o; + return this.condexpr_.equals(x.condexpr_); + } + return false; + } + + public int hashCode() { + return this.condexpr_.hashCode(); + } + + +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/PrettyPrinter.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/PrettyPrinter.java new file mode 100644 index 0000000..ed1276d --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/PrettyPrinter.java @@ -0,0 +1,1142 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query; +import pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.*; + +public class PrettyPrinter +{ + //For certain applications increasing the initial size of the buffer may improve performance. + private static final int INITIAL_BUFFER_SIZE = 128; + //You may wish to change the parentheses used in precedence. + private static final String _L_PAREN = new String("("); + private static final String _R_PAREN = new String(")"); + //You may wish to change render + private static void render(String s) + { + if (s.equals("{")) + { + buf_.append("\n"); + indent(); + buf_.append(s); + _n_ = _n_ + 2; + buf_.append("\n"); + indent(); + } + else if (s.equals("(") || s.equals("[")) + buf_.append(s); + else if (s.equals(")") || s.equals("]")) + { + backup(); + buf_.append(s); + buf_.append(" "); + } + else if (s.equals("}")) + { + _n_ = _n_ - 2; + backup(); + backup(); + buf_.append(s); + buf_.append("\n"); + indent(); + } + else if (s.equals(",")) + { + backup(); + buf_.append(s); + buf_.append(" "); + } + else if (s.equals(";")) + { + backup(); + buf_.append(s); + buf_.append("\n"); + indent(); + } + else if (s.equals("")) return; + else + { + buf_.append(s); + buf_.append(" "); + } + } + + + // print and show methods are defined for each category. + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String print(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp foo) + { + pp(foo, 0); + trim(); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + public static String show(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp foo) + { + sh(foo); + String temp = buf_.toString(); + buf_.delete(0,buf_.length()); + return temp; + } + /*** You shouldn't need to change anything beyond this point. ***/ + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement foo, int _i_) + { + for (java.util.Iterator<Statement> it = foo.iterator(); it.hasNext();) + { + pp(it.next(), 0); + if (it.hasNext()) { + render(";"); + } else { + render(""); + } + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem foo, int _i_) + { + for (java.util.Iterator<OrderItem> it = foo.iterator(); it.hasNext();) + { + pp(it.next(), 0); + if (it.hasNext()) { + render(","); + } else { + render(""); + } + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem foo, int _i_) + { + for (java.util.Iterator<SelItem> it = foo.iterator(); it.hasNext();) + { + pp(it.next(), 0); + if (it.hasNext()) { + render(","); + } else { + render(""); + } + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr foo, int _i_) + { + for (java.util.Iterator<CondExpr> it = foo.iterator(); it.hasNext();) + { + pp(it.next(), 0); + if (it.hasNext()) { + render(","); + } else { + render(""); + } + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC _programc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_programc.liststatement_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC _statementc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC) foo; + if (_i_ > 0) render(_L_PAREN); + render("SELECT"); + pp(_statementc.listselitem_, 0); + pp(_statementc.where_, 0); + pp(_statementc.orderby_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC) + { + if (_i_ > 0) render(_L_PAREN); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC _wherec = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC) foo; + if (_i_ > 0) render(_L_PAREN); + render("WHERE"); + pp(_wherec.condexpr_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC) + { + if (_i_ > 0) render(_L_PAREN); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC _orderbyc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC) foo; + if (_i_ > 0) render(_L_PAREN); + render("ORDER"); + render("BY"); + pp(_orderbyc.listorderitem_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC _orderitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_orderitemc.condexpr_, 0); + pp(_orderitemc.order_, 0); + pp(_orderitemc.nulls_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC) + { + if (_i_ > 0) render(_L_PAREN); + render("ASC"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC) + { + if (_i_ > 0) render(_L_PAREN); + render("DESC"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC) + { + if (_i_ > 0) render(_L_PAREN); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC) + { + if (_i_ > 0) render(_L_PAREN); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC) + { + if (_i_ > 0) render(_L_PAREN); + render("NULLS"); + render("FIRST"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC) + { + if (_i_ > 0) render(_L_PAREN); + render("NULLS"); + render("LAST"); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC _selitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_selitemc.condexpr_, 0); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC _aliasedselitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_aliasedselitemc.condexpr_, 0); + render("AS"); + pp(_aliasedselitemc.qident_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC _boolexprcmpc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_boolexprcmpc.basicexpr_1, 0); + pp(_boolexprcmpc.relop_, 0); + pp(_boolexprcmpc.basicexpr_2, 0); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC _boolexprregexpc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_boolexprregexpc.basicexpr_, 0); + render("REGEXP"); + printQuoted(_boolexprregexpc.string_); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC _boolexprbasicexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_boolexprbasicexprc.basicexpr_, 0); + if (_i_ > 0) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC _condexprorc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_condexprorc.condexpr_1, 0); + render("OR"); + pp(_condexprorc.condexpr_2, 1); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC _condexprandc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC) foo; + if (_i_ > 1) render(_L_PAREN); + pp(_condexprandc.condexpr_1, 1); + render("AND"); + pp(_condexprandc.condexpr_2, 2); + if (_i_ > 1) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC _condexprnotc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC) foo; + if (_i_ > 2) render(_L_PAREN); + render("NOT"); + pp(_condexprnotc.condexpr_, 2); + if (_i_ > 2) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC _condexprboolexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC) foo; + if (_i_ > 2) render(_L_PAREN); + pp(_condexprboolexprc.boolexpr_, 0); + if (_i_ > 2) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC _basicexpraddc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_basicexpraddc.basicexpr_1, 0); + render("+"); + pp(_basicexpraddc.basicexpr_2, 1); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC _basicexprsubc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC) foo; + if (_i_ > 0) render(_L_PAREN); + pp(_basicexprsubc.basicexpr_1, 0); + render("-"); + pp(_basicexprsubc.basicexpr_2, 1); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC _basicexprmulc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC) foo; + if (_i_ > 1) render(_L_PAREN); + pp(_basicexprmulc.basicexpr_1, 1); + render("*"); + pp(_basicexprmulc.basicexpr_2, 2); + if (_i_ > 1) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC _basicexprdivc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC) foo; + if (_i_ > 1) render(_L_PAREN); + pp(_basicexprdivc.basicexpr_1, 1); + render("/"); + pp(_basicexprdivc.basicexpr_2, 2); + if (_i_ > 1) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC _basicexprmodc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC) foo; + if (_i_ > 1) render(_L_PAREN); + pp(_basicexprmodc.basicexpr_1, 1); + render("%"); + pp(_basicexprmodc.basicexpr_2, 2); + if (_i_ > 1) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC _basicexprnegc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC) foo; + if (_i_ > 2) render(_L_PAREN); + render("-"); + pp(_basicexprnegc.basicexpr_, 2); + if (_i_ > 2) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC _eboolc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC) foo; + if (_i_ > 3) render(_L_PAREN); + pp(_eboolc.qbool_, 0); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC _eidentc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC) foo; + if (_i_ > 3) render(_L_PAREN); + pp(_eidentc.qident_, 0); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC _efunc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC) foo; + if (_i_ > 3) render(_L_PAREN); + pp(_efunc.qident_, 0); + render("("); + pp(_efunc.listcondexpr_, 0); + render(")"); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC _estrc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC) foo; + if (_i_ > 3) render(_L_PAREN); + printQuoted(_estrc.string_); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC _eintc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC) foo; + if (_i_ > 3) render(_L_PAREN); + pp(_eintc.qinteger_, 0); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC _edblc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC) foo; + if (_i_ > 3) render(_L_PAREN); + pp(_edblc.qdouble_, 0); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC _econdexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC) foo; + if (_i_ > 3) render(_L_PAREN); + render("("); + pp(_econdexprc.condexpr_, 0); + render(")"); + if (_i_ > 3) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC _estmtc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC) foo; + if (_i_ > 3) render(_L_PAREN); + render("("); + pp(_estmtc.statement_, 0); + render(")"); + if (_i_ > 3) render(_R_PAREN); + } + } + + private static void pp(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp foo, int _i_) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC) + { + if (_i_ > 0) render(_L_PAREN); + render(">"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC) + { + if (_i_ > 0) render(_L_PAREN); + render("="); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC) + { + if (_i_ > 0) render(_L_PAREN); + render("<>"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC) + { + if (_i_ > 0) render(_L_PAREN); + render("<"); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC) + { + if (_i_ > 0) render(_L_PAREN); + render("<="); + if (_i_ > 0) render(_R_PAREN); + } + else if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC) + { + if (_i_ > 0) render(_L_PAREN); + render(">="); + if (_i_ > 0) render(_R_PAREN); + } + } + + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement foo) + { + for (java.util.Iterator<Statement> it = foo.iterator(); it.hasNext();) + { + sh(it.next()); + if (it.hasNext()) + render(","); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem foo) + { + for (java.util.Iterator<OrderItem> it = foo.iterator(); it.hasNext();) + { + sh(it.next()); + if (it.hasNext()) + render(","); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem foo) + { + for (java.util.Iterator<SelItem> it = foo.iterator(); it.hasNext();) + { + sh(it.next()); + if (it.hasNext()) + render(","); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr foo) + { + for (java.util.Iterator<CondExpr> it = foo.iterator(); it.hasNext();) + { + sh(it.next()); + if (it.hasNext()) + render(","); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC _programc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC) foo; + render("("); + render("ProgramC"); + render("["); + sh(_programc.liststatement_); + render("]"); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC _statementc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC) foo; + render("("); + render("StatementC"); + render("["); + sh(_statementc.listselitem_); + render("]"); + sh(_statementc.where_); + sh(_statementc.orderby_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC) + { + render("NoWhereC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC _wherec = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC) foo; + render("("); + render("WhereC"); + sh(_wherec.condexpr_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC) + { + render("NoOrderByC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC _orderbyc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC) foo; + render("("); + render("OrderByC"); + render("["); + sh(_orderbyc.listorderitem_); + render("]"); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC _orderitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC) foo; + render("("); + render("OrderItemC"); + sh(_orderitemc.condexpr_); + sh(_orderitemc.order_); + sh(_orderitemc.nulls_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC) + { + render("AscOrderC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC) + { + render("DescOrderC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC) + { + render("NoOrderC"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC) + { + render("NoNullsC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC) + { + render("NullFirstsC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC) + { + render("NullsLastC"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC _selitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC) foo; + render("("); + render("SelItemC"); + sh(_selitemc.condexpr_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC _aliasedselitemc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC) foo; + render("("); + render("AliasedSelItemC"); + sh(_aliasedselitemc.condexpr_); + sh(_aliasedselitemc.qident_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC _boolexprcmpc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC) foo; + render("("); + render("BoolExprCmpC"); + sh(_boolexprcmpc.basicexpr_1); + sh(_boolexprcmpc.relop_); + sh(_boolexprcmpc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC _boolexprregexpc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC) foo; + render("("); + render("BoolExprRegExpC"); + sh(_boolexprregexpc.basicexpr_); + sh(_boolexprregexpc.string_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC _boolexprbasicexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC) foo; + render("("); + render("BoolExprBasicExprC"); + sh(_boolexprbasicexprc.basicexpr_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC _condexprorc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC) foo; + render("("); + render("CondExprOrC"); + sh(_condexprorc.condexpr_1); + sh(_condexprorc.condexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC _condexprandc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC) foo; + render("("); + render("CondExprAndC"); + sh(_condexprandc.condexpr_1); + sh(_condexprandc.condexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC _condexprnotc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC) foo; + render("("); + render("CondExprNotC"); + sh(_condexprnotc.condexpr_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC _condexprboolexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC) foo; + render("("); + render("CondExprBoolExprC"); + sh(_condexprboolexprc.boolexpr_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC _basicexpraddc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC) foo; + render("("); + render("BasicExprAddC"); + sh(_basicexpraddc.basicexpr_1); + sh(_basicexpraddc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC _basicexprsubc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC) foo; + render("("); + render("BasicExprSubC"); + sh(_basicexprsubc.basicexpr_1); + sh(_basicexprsubc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC _basicexprmulc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC) foo; + render("("); + render("BasicExprMulC"); + sh(_basicexprmulc.basicexpr_1); + sh(_basicexprmulc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC _basicexprdivc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC) foo; + render("("); + render("BasicExprDivC"); + sh(_basicexprdivc.basicexpr_1); + sh(_basicexprdivc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC _basicexprmodc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC) foo; + render("("); + render("BasicExprModC"); + sh(_basicexprmodc.basicexpr_1); + sh(_basicexprmodc.basicexpr_2); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC _basicexprnegc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC) foo; + render("("); + render("BasicExprNegC"); + sh(_basicexprnegc.basicexpr_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC _eboolc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC) foo; + render("("); + render("EBoolC"); + sh(_eboolc.qbool_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC _eidentc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC) foo; + render("("); + render("EIdentC"); + sh(_eidentc.qident_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC _efunc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC) foo; + render("("); + render("EFunC"); + sh(_efunc.qident_); + render("["); + sh(_efunc.listcondexpr_); + render("]"); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC _estrc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC) foo; + render("("); + render("EStrC"); + sh(_estrc.string_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC _eintc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC) foo; + render("("); + render("EIntC"); + sh(_eintc.qinteger_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC _edblc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC) foo; + render("("); + render("EDblC"); + sh(_edblc.qdouble_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC _econdexprc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC) foo; + render("("); + render("ECondExprC"); + sh(_econdexprc.condexpr_); + render(")"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC) + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC _estmtc = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC) foo; + render("("); + render("EStmtC"); + sh(_estmtc.statement_); + render(")"); + } + } + + private static void sh(pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp foo) + { + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC) + { + render("RelOpGtC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC) + { + render("RelOpEqC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC) + { + render("RelOpNeC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC) + { + render("RelOpLtC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC) + { + render("RelOpLeC"); + } + if (foo instanceof pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC) + { + render("RelOpGeC"); + } + } + + + private static void pp(String s, int _i_) { buf_.append(s); buf_.append(" "); } + private static void sh(String s) { printQuoted(s); } + private static void printQuoted(String s) { render("\"" + s + "\""); } + private static void indent() + { + int n = _n_; + while (n > 0) + { + buf_.append(" "); + n--; + } + } + private static void backup() + { + if (buf_.charAt(buf_.length() - 1) == ' ') { + buf_.setLength(buf_.length() - 1); + } + } + private static void trim() + { + while (buf_.length() > 0 && buf_.charAt(0) == ' ') + buf_.deleteCharAt(0); + while (buf_.length() > 0 && buf_.charAt(buf_.length()-1) == ' ') + buf_.deleteCharAt(buf_.length()-1); + } + private static int _n_ = 0; + private static StringBuilder buf_ = new StringBuilder(INITIAL_BUFFER_SIZE); +} + diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Test.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Test.java new file mode 100644 index 0000000..57ac1f8 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Test.java @@ -0,0 +1,46 @@ +package pl.edu.mimuw.cloudatlas.interpreter.query; +import java.io.FileNotFoundException; +import java.io.FileReader; + +public class Test +{ + public static void main(String args[]) throws Exception + { + Yylex l = null; + parser p; + try + { + if (args.length == 0) l = new Yylex(System.in); + else l = new Yylex(new FileReader(args[0])); + } + catch(FileNotFoundException e) + { + System.err.println("Error: File not found: " + args[0]); + System.exit(1); + } + p = new parser(l); + /* The default parser is the first-defined entry point. */ + /* You may want to change this. Other options are: */ + /* */ + try + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program parse_tree = p.pProgram(); + System.out.println(); + System.out.println("Parse Succesful!"); + System.out.println(); + System.out.println("[Abstract Syntax]"); + System.out.println(); + System.out.println(PrettyPrinter.show(parse_tree)); + System.out.println(); + System.out.println("[Linearized Tree]"); + System.out.println(); + System.out.println(PrettyPrinter.print(parse_tree)); + } + catch(Throwable e) + { + System.err.println("At line " + String.valueOf(l.line_num()) + ", near \"" + l.buff() + "\" :"); + System.err.println(" " + e.getMessage()); + System.exit(1); + } + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex new file mode 100644 index 0000000..4dd8029 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex @@ -0,0 +1,76 @@ +// This JLex file was machine-generated by the BNF converter +package pl.edu.mimuw.mmws.cloudatlas.query; + +import java_cup.runtime.*; +%% +%cup +%unicode +%line +%public +%{ + String pstring = new String(); + public int line_num() { return (yyline+1); } + public String buff() { return new String(yy_buffer,yy_buffer_index,10).trim(); } +%} +LETTER = ({CAPITAL}|{SMALL}) +CAPITAL = [A-Z\xC0-\xD6\xD8-\xDE] +SMALL = [a-z\xDF-\xF6\xF8-\xFF] +DIGIT = [0-9] +IDENT = ({LETTER}|{DIGIT}|['_]) +%state COMMENT +%state CHAR +%state CHARESC +%state CHAREND +%state STRING +%state ESCAPED +%% +<YYINITIAL>; { return new Symbol(sym._SYMB_0); } +<YYINITIAL>, { return new Symbol(sym._SYMB_1); } +<YYINITIAL>\+ { return new Symbol(sym._SYMB_2); } +<YYINITIAL>- { return new Symbol(sym._SYMB_3); } +<YYINITIAL>\* { return new Symbol(sym._SYMB_4); } +<YYINITIAL>/ { return new Symbol(sym._SYMB_5); } +<YYINITIAL>% { return new Symbol(sym._SYMB_6); } +<YYINITIAL>\( { return new Symbol(sym._SYMB_7); } +<YYINITIAL>\) { return new Symbol(sym._SYMB_8); } +<YYINITIAL>> { return new Symbol(sym._SYMB_9); } +<YYINITIAL>= { return new Symbol(sym._SYMB_10); } +<YYINITIAL><> { return new Symbol(sym._SYMB_11); } +<YYINITIAL>< { return new Symbol(sym._SYMB_12); } +<YYINITIAL><= { return new Symbol(sym._SYMB_13); } +<YYINITIAL>>= { return new Symbol(sym._SYMB_14); } +<YYINITIAL>AND { return new Symbol(sym._SYMB_15); } +<YYINITIAL>AS { return new Symbol(sym._SYMB_16); } +<YYINITIAL>ASC { return new Symbol(sym._SYMB_17); } +<YYINITIAL>BY { return new Symbol(sym._SYMB_18); } +<YYINITIAL>DESC { return new Symbol(sym._SYMB_19); } +<YYINITIAL>FIRST { return new Symbol(sym._SYMB_20); } +<YYINITIAL>LAST { return new Symbol(sym._SYMB_21); } +<YYINITIAL>NOT { return new Symbol(sym._SYMB_22); } +<YYINITIAL>NULLS { return new Symbol(sym._SYMB_23); } +<YYINITIAL>OR { return new Symbol(sym._SYMB_24); } +<YYINITIAL>ORDER { return new Symbol(sym._SYMB_25); } +<YYINITIAL>REGEXP { return new Symbol(sym._SYMB_26); } +<YYINITIAL>SELECT { return new Symbol(sym._SYMB_27); } +<YYINITIAL>WHERE { return new Symbol(sym._SYMB_28); } + +<YYINITIAL>true|false { return new Symbol(sym.QBool, yytext().intern()); } +<YYINITIAL>({LETTER}|&)({LETTER}|{DIGIT}|_)* { return new Symbol(sym.QIdent, yytext().intern()); } +<YYINITIAL>{DIGIT}*\.{DIGIT}+([eE]-?{DIGIT}+)?|{DIGIT}+([eE]-?{DIGIT}+) { return new Symbol(sym.QDouble, yytext().intern()); } +<YYINITIAL>0|[123456789]{DIGIT}* { return new Symbol(sym.QInteger, yytext().intern()); } + +<YYINITIAL>"\"" { yybegin(STRING); } +<STRING>\\ { yybegin(ESCAPED); } +<STRING>\" { String foo = pstring; pstring = new String(); yybegin(YYINITIAL); return new Symbol(sym._STRING_, foo.intern()); } +<STRING>. { pstring += yytext(); } +<ESCAPED>n { pstring += "\n"; yybegin(STRING); } +<ESCAPED>\" { pstring += "\""; yybegin(STRING); } +<ESCAPED>\\ { pstring += "\\"; yybegin(STRING); } +<ESCAPED>t { pstring += "\t"; yybegin(STRING); } +<ESCAPED>. { pstring += yytext(); yybegin(STRING); } + + + + + +<YYINITIAL>[ \t\r\n\f] { /* ignore white space. */ } diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex.java new file mode 100644 index 0000000..2fb69d7 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/Yylex.java @@ -0,0 +1,763 @@ +// This JLex file was machine-generated by the BNF converter +package pl.edu.mimuw.cloudatlas.interpreter.query; +import java_cup.runtime.*; + + +public class Yylex implements java_cup.runtime.Scanner { + private final int YY_BUFFER_SIZE = 512; + private final int YY_F = -1; + private final int YY_NO_STATE = -1; + private final int YY_NOT_ACCEPT = 0; + private final int YY_END = 2; + private final int YY_NO_ANCHOR = 4; + private final int YY_BOL = 65536; + private final int YY_EOF = 65537; + + String pstring = new String(); + public int line_num() { return (yyline+1); } + public String buff() { return new String(yy_buffer,yy_buffer_index,10).trim(); } + private java.io.BufferedReader yy_reader; + private int yy_buffer_index; + private int yy_buffer_read; + private int yy_buffer_start; + private int yy_buffer_end; + private char yy_buffer[]; + private int yyline; + private boolean yy_at_bol; + private int yy_lexical_state; + + public Yylex (java.io.Reader reader) { + this (); + if (null == reader) { + throw (new Error("Error: Bad input stream initializer.")); + } + yy_reader = new java.io.BufferedReader(reader); + } + + public Yylex (java.io.InputStream instream) { + this (); + if (null == instream) { + throw (new Error("Error: Bad input stream initializer.")); + } + yy_reader = new java.io.BufferedReader(new java.io.InputStreamReader(instream)); + } + + private Yylex () { + yy_buffer = new char[YY_BUFFER_SIZE]; + yy_buffer_read = 0; + yy_buffer_index = 0; + yy_buffer_start = 0; + yy_buffer_end = 0; + yyline = 0; + yy_at_bol = true; + yy_lexical_state = YYINITIAL; + } + + private final int STRING = 5; + private final int ESCAPED = 6; + private final int YYINITIAL = 0; + private final int yy_state_dtrans[] = { + 0, + 57, + 57, + 57, + 57, + 59, + 61 + }; + private void yybegin (int state) { + yy_lexical_state = state; + } + private int yy_advance () + throws java.io.IOException { + int next_read; + int i; + int j; + + if (yy_buffer_index < yy_buffer_read) { + return yy_buffer[yy_buffer_index++]; + } + + if (0 != yy_buffer_start) { + i = yy_buffer_start; + j = 0; + while (i < yy_buffer_read) { + yy_buffer[j] = yy_buffer[i]; + ++i; + ++j; + } + yy_buffer_end = yy_buffer_end - yy_buffer_start; + yy_buffer_start = 0; + yy_buffer_read = j; + yy_buffer_index = j; + next_read = yy_reader.read(yy_buffer, + yy_buffer_read, + yy_buffer.length - yy_buffer_read); + if (-1 == next_read) { + return YY_EOF; + } + yy_buffer_read = yy_buffer_read + next_read; + } + + while (yy_buffer_index >= yy_buffer_read) { + if (yy_buffer_index >= yy_buffer.length) { + yy_buffer = yy_double(yy_buffer); + } + next_read = yy_reader.read(yy_buffer, + yy_buffer_read, + yy_buffer.length - yy_buffer_read); + if (-1 == next_read) { + return YY_EOF; + } + yy_buffer_read = yy_buffer_read + next_read; + } + return yy_buffer[yy_buffer_index++]; + } + private void yy_move_end () { + if (yy_buffer_end > yy_buffer_start && + '\n' == yy_buffer[yy_buffer_end-1]) + yy_buffer_end--; + if (yy_buffer_end > yy_buffer_start && + '\r' == yy_buffer[yy_buffer_end-1]) + yy_buffer_end--; + } + private boolean yy_last_was_cr=false; + private void yy_mark_start () { + int i; + for (i = yy_buffer_start; i < yy_buffer_index; ++i) { + if ('\n' == yy_buffer[i] && !yy_last_was_cr) { + ++yyline; + } + if ('\r' == yy_buffer[i]) { + ++yyline; + yy_last_was_cr=true; + } else yy_last_was_cr=false; + } + yy_buffer_start = yy_buffer_index; + } + private void yy_mark_end () { + yy_buffer_end = yy_buffer_index; + } + private void yy_to_mark () { + yy_buffer_index = yy_buffer_end; + yy_at_bol = (yy_buffer_end > yy_buffer_start) && + ('\r' == yy_buffer[yy_buffer_end-1] || + '\n' == yy_buffer[yy_buffer_end-1] || + 2028/*LS*/ == yy_buffer[yy_buffer_end-1] || + 2029/*PS*/ == yy_buffer[yy_buffer_end-1]); + } + private java.lang.String yytext () { + return (new java.lang.String(yy_buffer, + yy_buffer_start, + yy_buffer_end - yy_buffer_start)); + } + private char[] yy_double (char buf[]) { + int i; + char newbuf[]; + newbuf = new char[2*buf.length]; + for (i = 0; i < buf.length; ++i) { + newbuf[i] = buf[i]; + } + return newbuf; + } + private final int YY_E_INTERNAL = 0; + private java.lang.String yy_error_string[] = { + "Error: Internal error.\n", + "Error: Unmatched input.\n" + }; + private void yy_error (int code,boolean fatal) { + java.lang.System.out.print(yy_error_string[code]); + java.lang.System.out.flush(); + if (fatal) { + throw new Error("Fatal Error.\n"); + } + } + private int[][] unpackFromString(int size1, int size2, String st) { + int colonIndex = -1; + String lengthString; + int sequenceLength = 0; + int sequenceInteger = 0; + + int commaIndex; + String workString; + + int res[][] = new int[size1][size2]; + for (int i= 0; i < size1; i++) { + for (int j= 0; j < size2; j++) { + if (sequenceLength != 0) { + res[i][j] = sequenceInteger; + sequenceLength--; + continue; + } + commaIndex = st.indexOf(','); + workString = (commaIndex==-1) ? st : + st.substring(0, commaIndex); + st = st.substring(commaIndex+1); + colonIndex = workString.indexOf(':'); + if (colonIndex == -1) { + res[i][j]=Integer.parseInt(workString); + continue; + } + lengthString = + workString.substring(colonIndex+1); + sequenceLength=Integer.parseInt(lengthString); + workString=workString.substring(0,colonIndex); + sequenceInteger=Integer.parseInt(workString); + res[i][j] = sequenceInteger; + sequenceLength--; + } + } + return res; + } + private int yy_acpt[] = { + /* 0 */ YY_NOT_ACCEPT, + /* 1 */ YY_NO_ANCHOR, + /* 2 */ YY_NO_ANCHOR, + /* 3 */ YY_NO_ANCHOR, + /* 4 */ YY_NO_ANCHOR, + /* 5 */ YY_NO_ANCHOR, + /* 6 */ YY_NO_ANCHOR, + /* 7 */ YY_NO_ANCHOR, + /* 8 */ YY_NO_ANCHOR, + /* 9 */ YY_NO_ANCHOR, + /* 10 */ YY_NO_ANCHOR, + /* 11 */ YY_NO_ANCHOR, + /* 12 */ YY_NO_ANCHOR, + /* 13 */ YY_NO_ANCHOR, + /* 14 */ YY_NO_ANCHOR, + /* 15 */ YY_NO_ANCHOR, + /* 16 */ YY_NO_ANCHOR, + /* 17 */ YY_NO_ANCHOR, + /* 18 */ YY_NO_ANCHOR, + /* 19 */ YY_NO_ANCHOR, + /* 20 */ YY_NO_ANCHOR, + /* 21 */ YY_NO_ANCHOR, + /* 22 */ YY_NO_ANCHOR, + /* 23 */ YY_NO_ANCHOR, + /* 24 */ YY_NO_ANCHOR, + /* 25 */ YY_NO_ANCHOR, + /* 26 */ YY_NO_ANCHOR, + /* 27 */ YY_NO_ANCHOR, + /* 28 */ YY_NO_ANCHOR, + /* 29 */ YY_NO_ANCHOR, + /* 30 */ YY_NO_ANCHOR, + /* 31 */ YY_NO_ANCHOR, + /* 32 */ YY_NO_ANCHOR, + /* 33 */ YY_NO_ANCHOR, + /* 34 */ YY_NO_ANCHOR, + /* 35 */ YY_NO_ANCHOR, + /* 36 */ YY_NO_ANCHOR, + /* 37 */ YY_NO_ANCHOR, + /* 38 */ YY_NO_ANCHOR, + /* 39 */ YY_NO_ANCHOR, + /* 40 */ YY_NO_ANCHOR, + /* 41 */ YY_NO_ANCHOR, + /* 42 */ YY_NO_ANCHOR, + /* 43 */ YY_NO_ANCHOR, + /* 44 */ YY_NO_ANCHOR, + /* 45 */ YY_NOT_ACCEPT, + /* 46 */ YY_NO_ANCHOR, + /* 47 */ YY_NO_ANCHOR, + /* 48 */ YY_NO_ANCHOR, + /* 49 */ YY_NOT_ACCEPT, + /* 50 */ YY_NO_ANCHOR, + /* 51 */ YY_NOT_ACCEPT, + /* 52 */ YY_NO_ANCHOR, + /* 53 */ YY_NOT_ACCEPT, + /* 54 */ YY_NO_ANCHOR, + /* 55 */ YY_NOT_ACCEPT, + /* 56 */ YY_NO_ANCHOR, + /* 57 */ YY_NOT_ACCEPT, + /* 58 */ YY_NO_ANCHOR, + /* 59 */ YY_NOT_ACCEPT, + /* 60 */ YY_NO_ANCHOR, + /* 61 */ YY_NOT_ACCEPT, + /* 62 */ YY_NO_ANCHOR, + /* 63 */ YY_NO_ANCHOR, + /* 64 */ YY_NO_ANCHOR, + /* 65 */ YY_NO_ANCHOR, + /* 66 */ YY_NO_ANCHOR, + /* 67 */ YY_NO_ANCHOR, + /* 68 */ YY_NO_ANCHOR, + /* 69 */ YY_NO_ANCHOR, + /* 70 */ YY_NO_ANCHOR, + /* 71 */ YY_NO_ANCHOR, + /* 72 */ YY_NO_ANCHOR, + /* 73 */ YY_NO_ANCHOR, + /* 74 */ YY_NO_ANCHOR, + /* 75 */ YY_NO_ANCHOR, + /* 76 */ YY_NO_ANCHOR, + /* 77 */ YY_NO_ANCHOR, + /* 78 */ YY_NO_ANCHOR, + /* 79 */ YY_NO_ANCHOR, + /* 80 */ YY_NO_ANCHOR, + /* 81 */ YY_NO_ANCHOR, + /* 82 */ YY_NO_ANCHOR, + /* 83 */ YY_NO_ANCHOR, + /* 84 */ YY_NO_ANCHOR, + /* 85 */ YY_NO_ANCHOR, + /* 86 */ YY_NO_ANCHOR, + /* 87 */ YY_NO_ANCHOR, + /* 88 */ YY_NO_ANCHOR, + /* 89 */ YY_NO_ANCHOR, + /* 90 */ YY_NO_ANCHOR, + /* 91 */ YY_NO_ANCHOR, + /* 92 */ YY_NO_ANCHOR, + /* 93 */ YY_NO_ANCHOR, + /* 94 */ YY_NO_ANCHOR, + /* 95 */ YY_NO_ANCHOR + }; + private int yy_cmap[] = unpackFromString(1,65538, +"49:9,51,52,49,51,52,49:18,51,49,47,49:2,7,42,49,8,9,5,3,2,4,45,6,46,43:9,49" + +",1,12,11,10,49:2,13,18,17,15,20,21,28,32,22,41:2,25,41,14,26,30,41,23,16,24" + +",27,41,31,29,19,41,49,48,49:2,44,49,38,41:3,36,37,41:5,39,41,50,41:3,34,40," + +"33,35,41:5,49:69,41:23,49,41:31,49,41:8,49:65280,0:2")[0]; + + private int yy_rmap[] = unpackFromString(1,96, +"0,1:10,2,1,3,4,5,1:5,6,7,8,9,7:12,1:8,10,11,12,13,14,15,12,16,13,17,14,18,1" + +"9,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,4" + +"4,45,46,47,48,49,7,50,51,52,53,54,55,56")[0]; + + private int yy_nxt[][] = unpackFromString(57,53, +"1,2,3,4,5,6,7,8,9,10,11,12,13,14,46,81,85,88,50,88:2,90,88,91,88,92,52,88:4" + +",93,88,94,88:3,95,88:5,15,-1,45,47,16,-1:2,88,17:2,-1:64,18,-1:51,19,20,-1:" + +"54,88,54,88,21,88:25,-1,88:2,-1,88,-1:3,88,-1:22,49,-1:15,49,-1:6,15,-1,45," + +"15,-1:19,88:4,26,88:24,-1,88:2,-1,88,-1:3,88,-1:15,88:29,-1,88:2,-1,88,-1:3" + +",88,-1:15,88:2,89,88:26,-1,88:2,-1,88,-1:3,88,-1:22,55,-1:15,55,-1:6,24,-1:" + +"2,24,-1:49,24,-1:2,24,-1:19,88:13,56,58,88:14,-1,88:2,-1,88,-1:3,88,-1:22,4" + +"9,-1:15,49,-1:6,51,-1,45,51,-1:49,48,-1:2,48,-1:10,53,-1:38,48,-1:2,48,-1:1" + +"9,88:6,22,88:22,-1,88:2,-1,88,-1:3,88,-1:15,88:10,23,88:18,-1,88:2,-1,88,-1" + +":3,88,-1:15,88:2,25,88:26,-1,88:2,-1,88,-1:3,88,-1:15,88:11,27,88:17,-1,88:" + +"2,-1,88,-1:3,88,-1:2,1,-1:65,88:12,86,88:16,-1,88:2,-1,88,-1:3,88,-1:2,1,37" + +":46,38,39,37:3,-1:14,88:3,67,88:25,-1,88:2,-1,88,-1:3,88,-1:2,1,40:32,41,40" + +":13,42,43,40,44,40,-1:14,88:10,68,88:18,-1,88:2,-1,88,-1:3,88,-1:15,88:15,8" + +"7,88:13,-1,88:2,-1,88,-1:3,88,-1:15,88:7,70,88:21,-1,88:2,-1,88,-1:3,88,-1:" + +"15,88:22,71,88:6,-1,88:2,-1,88,-1:3,88,-1:15,88:26,72,88:2,-1,88:2,-1,88,-1" + +":3,88,-1:15,88:4,28,88:24,-1,88:2,-1,88,-1:3,88,-1:15,88:3,75,88:25,-1,88:2" + +",-1,88,-1:3,88,-1:15,88:11,29,88:17,-1,88:2,-1,88,-1:3,88,-1:15,88:10,78,88" + +":18,-1,88:2,-1,88,-1:3,88,-1:15,88:23,30,88:5,-1,88:2,-1,88,-1:3,88,-1:15,8" + +"8:27,71,88,-1,88:2,-1,88,-1:3,88,-1:15,88:3,31,88:25,-1,88:2,-1,88,-1:3,88," + +"-1:15,88:4,79,88:24,-1,88:2,-1,88,-1:3,88,-1:15,88:11,32,88:17,-1,88:2,-1,8" + +"8,-1:3,88,-1:15,88:16,80,88:12,-1,88:2,-1,88,-1:3,88,-1:15,88:10,33,88:18,-" + +"1,88:2,-1,88,-1:3,88,-1:15,88:7,34,88:21,-1,88:2,-1,88,-1:3,88,-1:15,88:11," + +"35,88:17,-1,88:2,-1,88,-1:3,88,-1:15,88:17,36,88:11,-1,88:2,-1,88,-1:3,88,-" + +"1:15,88:7,60,88:21,-1,88:2,-1,88,-1:3,88,-1:15,88:12,84,88:16,-1,88:2,-1,88" + +",-1:3,88,-1:15,88:3,69,88:25,-1,88:2,-1,88,-1:3,88,-1:15,88:7,74,88:21,-1,8" + +"8:2,-1,88,-1:3,88,-1:15,88:7,82,88:21,-1,88:2,-1,88,-1:3,88,-1:15,88:12,73," + +"88:16,-1,88:2,-1,88,-1:3,88,-1:15,88:7,76,88:21,-1,88:2,-1,88,-1:3,88,-1:15" + +",88:7,77,88:21,-1,88:2,-1,88,-1:3,88,-1:15,88:9,62,88:19,-1,88:2,-1,88,-1:3" + +",88,-1:15,88:7,63,88:21,-1,88:2,-1,88,-1:3,88,-1:15,83,88:28,-1,88:2,-1,88," + +"-1:3,88,-1:15,88:19,64,88:9,-1,88:2,-1,88,-1:3,88,-1:15,88:21,65,88:7,-1,88" + +":2,-1,88,-1:3,88,-1:15,88:25,66,88:3,-1,88:2,-1,88,-1:3,88,-1:2"); + + public java_cup.runtime.Symbol next_token () + throws java.io.IOException { + int yy_lookahead; + int yy_anchor = YY_NO_ANCHOR; + int yy_state = yy_state_dtrans[yy_lexical_state]; + int yy_next_state = YY_NO_STATE; + int yy_last_accept_state = YY_NO_STATE; + boolean yy_initial = true; + int yy_this_accept; + + yy_mark_start(); + yy_this_accept = yy_acpt[yy_state]; + if (YY_NOT_ACCEPT != yy_this_accept) { + yy_last_accept_state = yy_state; + yy_mark_end(); + } + while (true) { + if (yy_initial && yy_at_bol) yy_lookahead = YY_BOL; + else yy_lookahead = yy_advance(); + yy_next_state = YY_F; + yy_next_state = yy_nxt[yy_rmap[yy_state]][yy_cmap[yy_lookahead]]; + if (YY_EOF == yy_lookahead && true == yy_initial) { + return null; + } + if (YY_F != yy_next_state) { + yy_state = yy_next_state; + yy_initial = false; + yy_this_accept = yy_acpt[yy_state]; + if (YY_NOT_ACCEPT != yy_this_accept) { + yy_last_accept_state = yy_state; + yy_mark_end(); + } + } + else { + if (YY_NO_STATE == yy_last_accept_state) { + throw (new Error("Lexical Error: Unmatched Input.")); + } + else { + yy_anchor = yy_acpt[yy_last_accept_state]; + if (0 != (YY_END & yy_anchor)) { + yy_move_end(); + } + yy_to_mark(); + switch (yy_last_accept_state) { + case 1: + + case -2: + break; + case 2: + { return new Symbol(sym._SYMB_0); } + case -3: + break; + case 3: + { return new Symbol(sym._SYMB_1); } + case -4: + break; + case 4: + { return new Symbol(sym._SYMB_2); } + case -5: + break; + case 5: + { return new Symbol(sym._SYMB_3); } + case -6: + break; + case 6: + { return new Symbol(sym._SYMB_4); } + case -7: + break; + case 7: + { return new Symbol(sym._SYMB_5); } + case -8: + break; + case 8: + { return new Symbol(sym._SYMB_6); } + case -9: + break; + case 9: + { return new Symbol(sym._SYMB_7); } + case -10: + break; + case 10: + { return new Symbol(sym._SYMB_8); } + case -11: + break; + case 11: + { return new Symbol(sym._SYMB_9); } + case -12: + break; + case 12: + { return new Symbol(sym._SYMB_10); } + case -13: + break; + case 13: + { return new Symbol(sym._SYMB_12); } + case -14: + break; + case 14: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -15: + break; + case 15: + { return new Symbol(sym.QInteger, yytext().intern()); } + case -16: + break; + case 16: + { yybegin(STRING); } + case -17: + break; + case 17: + { /* ignore white space. */ } + case -18: + break; + case 18: + { return new Symbol(sym._SYMB_14); } + case -19: + break; + case 19: + { return new Symbol(sym._SYMB_11); } + case -20: + break; + case 20: + { return new Symbol(sym._SYMB_13); } + case -21: + break; + case 21: + { return new Symbol(sym._SYMB_16); } + case -22: + break; + case 22: + { return new Symbol(sym._SYMB_18); } + case -23: + break; + case 23: + { return new Symbol(sym._SYMB_24); } + case -24: + break; + case 24: + { return new Symbol(sym.QDouble, yytext().intern()); } + case -25: + break; + case 25: + { return new Symbol(sym._SYMB_15); } + case -26: + break; + case 26: + { return new Symbol(sym._SYMB_17); } + case -27: + break; + case 27: + { return new Symbol(sym._SYMB_22); } + case -28: + break; + case 28: + { return new Symbol(sym._SYMB_19); } + case -29: + break; + case 29: + { return new Symbol(sym._SYMB_21); } + case -30: + break; + case 30: + { return new Symbol(sym.QBool, yytext().intern()); } + case -31: + break; + case 31: + { return new Symbol(sym._SYMB_23); } + case -32: + break; + case 32: + { return new Symbol(sym._SYMB_20); } + case -33: + break; + case 33: + { return new Symbol(sym._SYMB_25); } + case -34: + break; + case 34: + { return new Symbol(sym._SYMB_28); } + case -35: + break; + case 35: + { return new Symbol(sym._SYMB_27); } + case -36: + break; + case 36: + { return new Symbol(sym._SYMB_26); } + case -37: + break; + case 37: + { pstring += yytext(); } + case -38: + break; + case 38: + { String foo = pstring; pstring = new String(); yybegin(YYINITIAL); return new Symbol(sym._STRING_, foo.intern()); } + case -39: + break; + case 39: + { yybegin(ESCAPED); } + case -40: + break; + case 40: + { pstring += yytext(); yybegin(STRING); } + case -41: + break; + case 41: + { pstring += "\t"; yybegin(STRING); } + case -42: + break; + case 42: + { pstring += "\""; yybegin(STRING); } + case -43: + break; + case 43: + { pstring += "\\"; yybegin(STRING); } + case -44: + break; + case 44: + { pstring += "\n"; yybegin(STRING); } + case -45: + break; + case 46: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -46: + break; + case 47: + { return new Symbol(sym.QInteger, yytext().intern()); } + case -47: + break; + case 48: + { return new Symbol(sym.QDouble, yytext().intern()); } + case -48: + break; + case 50: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -49: + break; + case 52: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -50: + break; + case 54: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -51: + break; + case 56: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -52: + break; + case 58: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -53: + break; + case 60: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -54: + break; + case 62: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -55: + break; + case 63: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -56: + break; + case 64: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -57: + break; + case 65: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -58: + break; + case 66: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -59: + break; + case 67: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -60: + break; + case 68: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -61: + break; + case 69: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -62: + break; + case 70: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -63: + break; + case 71: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -64: + break; + case 72: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -65: + break; + case 73: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -66: + break; + case 74: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -67: + break; + case 75: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -68: + break; + case 76: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -69: + break; + case 77: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -70: + break; + case 78: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -71: + break; + case 79: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -72: + break; + case 80: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -73: + break; + case 81: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -74: + break; + case 82: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -75: + break; + case 83: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -76: + break; + case 84: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -77: + break; + case 85: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -78: + break; + case 86: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -79: + break; + case 87: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -80: + break; + case 88: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -81: + break; + case 89: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -82: + break; + case 90: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -83: + break; + case 91: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -84: + break; + case 92: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -85: + break; + case 93: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -86: + break; + case 94: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -87: + break; + case 95: + { return new Symbol(sym.QIdent, yytext().intern()); } + case -88: + break; + default: + yy_error(YY_E_INTERNAL,false); + case -1: + } + yy_initial = true; + yy_state = yy_state_dtrans[yy_lexical_state]; + yy_next_state = YY_NO_STATE; + yy_last_accept_state = YY_NO_STATE; + yy_mark_start(); + yy_this_accept = yy_acpt[yy_state]; + if (YY_NOT_ACCEPT != yy_this_accept) { + yy_last_accept_state = yy_state; + yy_mark_end(); + } + } + } + } + } +} diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/parser.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/parser.java new file mode 100644 index 0000000..85a196b --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/parser.java @@ -0,0 +1,923 @@ + +//---------------------------------------------------- +// The following code was generated by CUP v0.11a beta 20060608 +// Sat Nov 16 17:39:43 CET 2013 +//---------------------------------------------------- + +package pl.edu.mimuw.cloudatlas.interpreter.query; + + +/** CUP v0.11a beta 20060608 generated parser. + * @version Sat Nov 16 17:39:43 CET 2013 + */ +public class parser extends java_cup.runtime.lr_parser { + + /** Default constructor. */ + public parser() {super();} + + /** Constructor which sets the default scanner. */ + public parser(java_cup.runtime.Scanner s) {super(s);} + + /** Constructor which sets the default scanner. */ + public parser(java_cup.runtime.Scanner s, java_cup.runtime.SymbolFactory sf) {super(s,sf);} + + /** Production table. */ + protected static final short _production_table[][] = + unpackFromStrings(new String[] { + "\000\071\000\002\002\004\000\002\002\003\000\002\002" + + "\005\000\002\003\003\000\002\003\005\000\002\004\003" + + "\000\002\004\005\000\002\005\002\000\002\005\003\000" + + "\002\005\005\000\002\006\003\000\002\007\006\000\002" + + "\010\002\000\002\010\004\000\002\011\002\000\002\011" + + "\005\000\002\012\005\000\002\013\003\000\002\013\003" + + "\000\002\013\002\000\002\014\002\000\002\014\004\000" + + "\002\014\004\000\002\015\003\000\002\015\005\000\002" + + "\016\005\000\002\016\005\000\002\016\003\000\002\017" + + "\005\000\002\017\003\000\002\020\005\000\002\020\003" + + "\000\002\021\004\000\002\021\003\000\002\022\005\000" + + "\002\022\005\000\002\022\003\000\002\023\005\000\002" + + "\023\005\000\002\023\005\000\002\023\003\000\002\024" + + "\004\000\002\024\003\000\002\025\003\000\002\025\003" + + "\000\002\025\006\000\002\025\003\000\002\025\003\000" + + "\002\025\003\000\002\025\005\000\002\025\005\000\002" + + "\026\003\000\002\026\003\000\002\026\003\000\002\026" + + "\003\000\002\026\003\000\002\026\003" }); + + /** Access to production table. */ + public short[][] production_table() {return _production_table;} + + /** Parse-action table. */ + protected static final short[][] _action_table = + unpackFromStrings(new String[] { + "\000\124\000\004\037\006\001\002\000\004\002\126\001" + + "\002\000\006\002\000\004\124\001\002\000\022\007\024" + + "\013\023\032\030\041\012\042\026\043\025\044\015\045" + + "\016\001\002\000\004\002\ufff7\001\002\000\062\002\uffd7" + + "\004\uffd7\005\uffd7\006\uffd7\007\uffd7\010\uffd7\011\uffd7\012" + + "\uffd7\014\uffd7\015\uffd7\016\uffd7\017\uffd7\020\uffd7\021\uffd7" + + "\022\uffd7\023\uffd7\024\uffd7\025\uffd7\027\uffd7\033\uffd7\034" + + "\uffd7\035\uffd7\036\uffd7\040\uffd7\001\002\000\062\002\uffd9" + + "\004\uffd9\005\uffd9\006\uffd9\007\uffd9\010\uffd9\011\uffd9\012" + + "\uffd9\014\uffd9\015\uffd9\016\uffd9\017\uffd9\020\uffd9\021\uffd9" + + "\022\uffd9\023\uffd9\024\uffd9\025\uffd9\027\uffd9\033\uffd9\034" + + "\uffd9\035\uffd9\036\uffd9\040\uffd9\001\002\000\062\002\uffd3" + + "\004\uffd3\005\uffd3\006\uffd3\007\uffd3\010\uffd3\011\uffd3\012" + + "\uffd3\014\uffd3\015\uffd3\016\uffd3\017\uffd3\020\uffd3\021\uffd3" + + "\022\uffd3\023\uffd3\024\uffd3\025\uffd3\027\uffd3\033\uffd3\034" + + "\uffd3\035\uffd3\036\uffd3\040\uffd3\001\002\000\054\002\uffe6" + + "\004\uffe6\005\uffe6\006\110\007\107\014\uffe6\015\117\016" + + "\116\017\115\020\114\021\113\022\111\023\uffe6\024\uffe6" + + "\025\uffe6\027\uffe6\033\uffe6\034\uffe6\035\uffe6\036\106\040" + + "\uffe6\001\002\000\062\002\uffdd\004\uffdd\005\uffdd\006\uffdd" + + "\007\uffdd\010\100\011\102\012\101\014\uffdd\015\uffdd\016" + + "\uffdd\017\uffdd\020\uffdd\021\uffdd\022\uffdd\023\uffdd\024\uffdd" + + "\025\uffdd\027\uffdd\033\uffdd\034\uffdd\035\uffdd\036\uffdd\040" + + "\uffdd\001\002\000\062\002\uffd1\004\uffd1\005\uffd1\006\uffd1" + + "\007\uffd1\010\uffd1\011\uffd1\012\uffd1\014\uffd1\015\uffd1\016" + + "\uffd1\017\uffd1\020\uffd1\021\uffd1\022\uffd1\023\uffd1\024\uffd1" + + "\025\uffd1\027\uffd1\033\uffd1\034\uffd1\035\uffd1\036\uffd1\040" + + "\uffd1\001\002\000\062\002\uffd2\004\uffd2\005\uffd2\006\uffd2" + + "\007\uffd2\010\uffd2\011\uffd2\012\uffd2\014\uffd2\015\uffd2\016" + + "\uffd2\017\uffd2\020\uffd2\021\uffd2\022\uffd2\023\uffd2\024\uffd2" + + "\025\uffd2\027\uffd2\033\uffd2\034\uffd2\035\uffd2\036\uffd2\040" + + "\uffd2\001\002\000\014\002\ufff5\004\ufff5\014\ufff5\035\ufff5" + + "\040\056\001\002\000\022\002\uffea\004\uffea\005\uffea\014" + + "\uffea\024\054\034\042\035\uffea\040\uffea\001\002\000\032" + + "\002\uffe2\004\uffe2\005\uffe2\014\uffe2\023\uffe2\024\uffe2\025" + + "\uffe2\027\uffe2\033\uffe2\034\uffe2\035\uffe2\040\uffe2\001\002" + + "\000\032\002\uffe4\004\uffe4\005\uffe4\014\uffe4\023\044\024" + + "\uffe4\025\uffe4\027\uffe4\033\uffe4\034\uffe4\035\uffe4\040\uffe4" + + "\001\002\000\024\007\024\013\023\032\030\037\006\041" + + "\012\042\026\043\025\044\015\045\016\001\002\000\020" + + "\007\024\013\023\041\012\042\026\043\025\044\015\045" + + "\016\001\002\000\064\002\uffd5\004\uffd5\005\uffd5\006\uffd5" + + "\007\uffd5\010\uffd5\011\uffd5\012\uffd5\013\035\014\uffd5\015" + + "\uffd5\016\uffd5\017\uffd5\020\uffd5\021\uffd5\022\uffd5\023\uffd5" + + "\024\uffd5\025\uffd5\027\uffd5\033\uffd5\034\uffd5\035\uffd5\036" + + "\uffd5\040\uffd5\001\002\000\062\002\uffd6\004\uffd6\005\uffd6" + + "\006\uffd6\007\uffd6\010\uffd6\011\uffd6\012\uffd6\014\uffd6\015" + + "\uffd6\016\uffd6\017\uffd6\020\uffd6\021\uffd6\022\uffd6\023\uffd6" + + "\024\uffd6\025\uffd6\027\uffd6\033\uffd6\034\uffd6\035\uffd6\036" + + "\uffd6\040\uffd6\001\002\000\016\002\ufffc\004\ufffc\005\033" + + "\014\ufffc\035\ufffc\040\ufffc\001\002\000\022\007\024\013" + + "\023\032\030\041\012\042\026\043\025\044\015\045\016" + + "\001\002\000\032\002\uffe0\004\uffe0\005\uffe0\014\uffe0\023" + + "\uffe0\024\uffe0\025\uffe0\027\uffe0\033\uffe0\034\uffe0\035\uffe0" + + "\040\uffe0\001\002\000\032\002\uffe1\004\uffe1\005\uffe1\014" + + "\uffe1\023\uffe1\024\uffe1\025\uffe1\027\uffe1\033\uffe1\034\uffe1" + + "\035\uffe1\040\uffe1\001\002\000\022\007\024\013\023\032" + + "\030\041\012\042\026\043\025\044\015\045\016\001\002" + + "\000\014\002\ufffb\004\ufffb\014\ufffb\035\ufffb\040\ufffb\001" + + "\002\000\024\007\024\013\023\014\ufffa\032\030\041\012" + + "\042\026\043\025\044\015\045\016\001\002\000\010\005" + + "\041\014\ufff9\034\042\001\002\000\004\014\040\001\002" + + "\000\062\002\uffd4\004\uffd4\005\uffd4\006\uffd4\007\uffd4\010" + + "\uffd4\011\uffd4\012\uffd4\014\uffd4\015\uffd4\016\uffd4\017\uffd4" + + "\020\uffd4\021\uffd4\022\uffd4\023\uffd4\024\uffd4\025\uffd4\027" + + "\uffd4\033\uffd4\034\uffd4\035\uffd4\036\uffd4\040\uffd4\001\002" + + "\000\024\007\024\013\023\014\ufffa\032\030\041\012\042" + + "\026\043\025\044\015\045\016\001\002\000\022\007\024" + + "\013\023\032\030\041\012\042\026\043\025\044\015\045" + + "\016\001\002\000\032\002\uffe5\004\uffe5\005\uffe5\014\uffe5" + + "\023\044\024\uffe5\025\uffe5\027\uffe5\033\uffe5\034\uffe5\035" + + "\uffe5\040\uffe5\001\002\000\022\007\024\013\023\032\030" + + "\041\012\042\026\043\025\044\015\045\016\001\002\000" + + "\032\002\uffe3\004\uffe3\005\uffe3\014\uffe3\023\uffe3\024\uffe3" + + "\025\uffe3\027\uffe3\033\uffe3\034\uffe3\035\uffe3\040\uffe3\001" + + "\002\000\004\014\ufff8\001\002\000\062\002\uffd8\004\uffd8" + + "\005\uffd8\006\uffd8\007\uffd8\010\uffd8\011\uffd8\012\uffd8\014" + + "\uffd8\015\uffd8\016\uffd8\017\uffd8\020\uffd8\021\uffd8\022\uffd8" + + "\023\uffd8\024\uffd8\025\uffd8\027\uffd8\033\uffd8\034\uffd8\035" + + "\uffd8\036\uffd8\040\uffd8\001\002\000\006\014\053\034\042" + + "\001\002\000\004\014\052\001\002\000\062\002\uffcf\004" + + "\uffcf\005\uffcf\006\uffcf\007\uffcf\010\uffcf\011\uffcf\012\uffcf" + + "\014\uffcf\015\uffcf\016\uffcf\017\uffcf\020\uffcf\021\uffcf\022" + + "\uffcf\023\uffcf\024\uffcf\025\uffcf\027\uffcf\033\uffcf\034\uffcf" + + "\035\uffcf\036\uffcf\040\uffcf\001\002\000\062\002\uffd0\004" + + "\uffd0\005\uffd0\006\uffd0\007\uffd0\010\uffd0\011\uffd0\012\uffd0" + + "\014\uffd0\015\uffd0\016\uffd0\017\uffd0\020\uffd0\021\uffd0\022" + + "\uffd0\023\uffd0\024\uffd0\025\uffd0\027\uffd0\033\uffd0\034\uffd0" + + "\035\uffd0\036\uffd0\040\uffd0\001\002\000\004\043\055\001" + + "\002\000\016\002\uffe9\004\uffe9\005\uffe9\014\uffe9\035\uffe9" + + "\040\uffe9\001\002\000\022\007\024\013\023\032\030\041" + + "\012\042\026\043\025\044\015\045\016\001\002\000\012" + + "\002\ufff3\004\ufff3\014\ufff3\035\061\001\002\000\010\002" + + "\ufff6\004\ufff6\014\ufff6\001\002\000\004\026\062\001\002" + + "\000\022\007\024\013\023\032\030\041\012\042\026\043" + + "\025\044\015\045\016\001\002\000\012\002\ufffe\004\ufffe" + + "\005\075\014\ufffe\001\002\000\022\002\uffee\004\uffee\005" + + "\uffee\014\uffee\025\067\027\066\033\uffee\034\042\001\002" + + "\000\010\002\ufff2\004\ufff2\014\ufff2\001\002\000\014\002" + + "\uffef\004\uffef\005\uffef\014\uffef\033\uffef\001\002\000\014" + + "\002\ufff0\004\ufff0\005\ufff0\014\ufff0\033\ufff0\001\002\000" + + "\014\002\uffed\004\uffed\005\uffed\014\uffed\033\072\001\002" + + "\000\012\002\ufff1\004\ufff1\005\ufff1\014\ufff1\001\002\000" + + "\006\030\074\031\073\001\002\000\012\002\uffeb\004\uffeb" + + "\005\uffeb\014\uffeb\001\002\000\012\002\uffec\004\uffec\005" + + "\uffec\014\uffec\001\002\000\022\007\024\013\023\032\030" + + "\041\012\042\026\043\025\044\015\045\016\001\002\000" + + "\010\002\ufffd\004\ufffd\014\ufffd\001\002\000\014\002\ufff4" + + "\004\ufff4\014\ufff4\034\042\035\ufff4\001\002\000\020\007" + + "\024\013\023\041\012\042\026\043\025\044\015\045\016" + + "\001\002\000\020\007\024\013\023\041\012\042\026\043" + + "\025\044\015\045\016\001\002\000\020\007\024\013\023" + + "\041\012\042\026\043\025\044\015\045\016\001\002\000" + + "\062\002\uffdb\004\uffdb\005\uffdb\006\uffdb\007\uffdb\010\uffdb" + + "\011\uffdb\012\uffdb\014\uffdb\015\uffdb\016\uffdb\017\uffdb\020" + + "\uffdb\021\uffdb\022\uffdb\023\uffdb\024\uffdb\025\uffdb\027\uffdb" + + "\033\uffdb\034\uffdb\035\uffdb\036\uffdb\040\uffdb\001\002\000" + + "\062\002\uffda\004\uffda\005\uffda\006\uffda\007\uffda\010\uffda" + + "\011\uffda\012\uffda\014\uffda\015\uffda\016\uffda\017\uffda\020" + + "\uffda\021\uffda\022\uffda\023\uffda\024\uffda\025\uffda\027\uffda" + + "\033\uffda\034\uffda\035\uffda\036\uffda\040\uffda\001\002\000" + + "\062\002\uffdc\004\uffdc\005\uffdc\006\uffdc\007\uffdc\010\uffdc" + + "\011\uffdc\012\uffdc\014\uffdc\015\uffdc\016\uffdc\017\uffdc\020" + + "\uffdc\021\uffdc\022\uffdc\023\uffdc\024\uffdc\025\uffdc\027\uffdc" + + "\033\uffdc\034\uffdc\035\uffdc\036\uffdc\040\uffdc\001\002\000" + + "\004\041\123\001\002\000\020\007\024\013\023\041\012" + + "\042\026\043\025\044\015\045\016\001\002\000\020\007" + + "\024\013\023\041\012\042\026\043\025\044\015\045\016" + + "\001\002\000\020\007\uffc9\013\uffc9\041\uffc9\042\uffc9\043" + + "\uffc9\044\uffc9\045\uffc9\001\002\000\020\007\024\013\023" + + "\041\012\042\026\043\025\044\015\045\016\001\002\000" + + "\020\007\uffca\013\uffca\041\uffca\042\uffca\043\uffca\044\uffca" + + "\045\uffca\001\002\000\020\007\uffcb\013\uffcb\041\uffcb\042" + + "\uffcb\043\uffcb\044\uffcb\045\uffcb\001\002\000\020\007\uffcc" + + "\013\uffcc\041\uffcc\042\uffcc\043\uffcc\044\uffcc\045\uffcc\001" + + "\002\000\020\007\uffcd\013\uffcd\041\uffcd\042\uffcd\043\uffcd" + + "\044\uffcd\045\uffcd\001\002\000\020\007\uffce\013\uffce\041" + + "\uffce\042\uffce\043\uffce\044\uffce\045\uffce\001\002\000\036" + + "\002\uffe8\004\uffe8\005\uffe8\006\110\007\107\014\uffe8\023" + + "\uffe8\024\uffe8\025\uffe8\027\uffe8\033\uffe8\034\uffe8\035\uffe8" + + "\040\uffe8\001\002\000\062\002\uffdf\004\uffdf\005\uffdf\006" + + "\uffdf\007\uffdf\010\100\011\102\012\101\014\uffdf\015\uffdf" + + "\016\uffdf\017\uffdf\020\uffdf\021\uffdf\022\uffdf\023\uffdf\024" + + "\uffdf\025\uffdf\027\uffdf\033\uffdf\034\uffdf\035\uffdf\036\uffdf" + + "\040\uffdf\001\002\000\062\002\uffde\004\uffde\005\uffde\006" + + "\uffde\007\uffde\010\100\011\102\012\101\014\uffde\015\uffde" + + "\016\uffde\017\uffde\020\uffde\021\uffde\022\uffde\023\uffde\024" + + "\uffde\025\uffde\027\uffde\033\uffde\034\uffde\035\uffde\036\uffde" + + "\040\uffde\001\002\000\032\002\uffe7\004\uffe7\005\uffe7\014" + + "\uffe7\023\uffe7\024\uffe7\025\uffe7\027\uffe7\033\uffe7\034\uffe7" + + "\035\uffe7\040\uffe7\001\002\000\004\037\006\001\002\000" + + "\004\002\uffff\001\002\000\004\002\001\001\002" }); + + /** Access to parse-action table. */ + public short[][] action_table() {return _action_table;} + + /** <code>reduce_goto</code> table. */ + protected static final short[][] _reduce_table = + unpackFromStrings(new String[] { + "\000\124\000\010\002\006\006\003\007\004\001\001\000" + + "\002\001\001\000\002\001\001\000\026\004\016\015\026" + + "\016\030\017\017\020\021\021\020\022\012\023\013\024" + + "\010\025\007\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\004\026\111\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\004\010\056\001\001\000\002\001\001\000\002\001" + + "\001\000\002\001\001\000\024\007\050\016\030\017\047" + + "\020\021\021\020\022\012\023\013\024\010\025\007\001" + + "\001\000\006\024\046\025\007\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\016\016\030\021" + + "\031\022\012\023\013\024\010\025\007\001\001\000\002" + + "\001\001\000\002\001\001\000\026\004\033\015\026\016" + + "\030\017\017\020\021\021\020\022\012\023\013\024\010" + + "\025\007\001\001\000\002\001\001\000\024\005\036\016" + + "\030\017\035\020\021\021\020\022\012\023\013\024\010" + + "\025\007\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\024\005\045\016\030\017\035\020\021" + + "\021\020\022\012\023\013\024\010\025\007\001\001\000" + + "\020\016\030\020\042\021\020\022\012\023\013\024\010" + + "\025\007\001\001\000\002\001\001\000\016\016\030\021" + + "\044\022\012\023\013\024\010\025\007\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\022\016\030\017" + + "\076\020\021\021\020\022\012\023\013\024\010\025\007" + + "\001\001\000\004\011\057\001\001\000\002\001\001\000" + + "\002\001\001\000\026\003\064\012\062\016\030\017\063" + + "\020\021\021\020\022\012\023\013\024\010\025\007\001" + + "\001\000\002\001\001\000\004\013\067\001\001\000\002" + + "\001\001\000\002\001\001\000\002\001\001\000\004\014" + + "\070\001\001\000\002\001\001\000\002\001\001\000\002" + + "\001\001\000\002\001\001\000\026\003\075\012\062\016" + + "\030\017\063\020\021\021\020\022\012\023\013\024\010" + + "\025\007\001\001\000\002\001\001\000\002\001\001\000" + + "\006\024\104\025\007\001\001\000\006\024\103\025\007" + + "\001\001\000\006\024\102\025\007\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\010\023\121\024\010\025\007\001\001\000\010\023" + + "\120\024\010\025\007\001\001\000\002\001\001\000\012" + + "\022\117\023\013\024\010\025\007\001\001\000\002\001" + + "\001\000\002\001\001\000\002\001\001\000\002\001\001" + + "\000\002\001\001\000\002\001\001\000\002\001\001\000" + + "\002\001\001\000\002\001\001\000\006\002\124\007\004" + + "\001\001\000\002\001\001\000\002\001\001" }); + + /** Access to <code>reduce_goto</code> table. */ + public short[][] reduce_table() {return _reduce_table;} + + /** Instance of action encapsulation class. */ + protected CUP$parser$actions action_obj; + + /** Action encapsulation object initializer. */ + protected void init_actions() + { + action_obj = new CUP$parser$actions(this); + } + + /** Invoke a user supplied parse action. */ + public java_cup.runtime.Symbol do_action( + int act_num, + java_cup.runtime.lr_parser parser, + @SuppressWarnings("rawtypes") java.util.Stack stack, + int top) + throws java.lang.Exception + { + /* call code in generated class */ + return action_obj.CUP$parser$do_action(act_num, parser, stack, top); + } + + /** Indicates start state. */ + public int start_state() {return 0;} + /** Indicates start production. */ + public int start_production() {return 0;} + + /** <code>EOF</code> Symbol index. */ + public int EOF_sym() {return 0;} + + /** <code>error</code> Symbol index. */ + public int error_sym() {return 1;} + + + + public pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program pProgram() throws Exception + { + java_cup.runtime.Symbol res = parse(); + return (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program) res.value; + } + +public <B,A extends java.util.LinkedList<? super B>> A cons_(B x, A xs) { xs.addFirst(x); return xs; } + +public void syntax_error(java_cup.runtime.Symbol cur_token) +{ + report_error("Syntax Error, trying to recover and continue parse...", cur_token); +} + +public void unrecovered_syntax_error(java_cup.runtime.Symbol cur_token) throws java.lang.Exception +{ + throw new Exception("Unrecoverable Syntax Error"); +} + + +} + +/** Cup generated class to encapsulate user supplied action code.*/ +class CUP$parser$actions { + private final parser parser; + + /** Constructor */ + CUP$parser$actions(parser parser) { + this.parser = parser; + } + + /** Method with the actual generated action code. */ + public final java_cup.runtime.Symbol CUP$parser$do_action( + int CUP$parser$act_num, + java_cup.runtime.lr_parser CUP$parser$parser, + @SuppressWarnings("rawtypes") java.util.Stack CUP$parser$stack, + int CUP$parser$top) + throws java.lang.Exception + { + /* Symbol object for return from actions */ + java_cup.runtime.Symbol CUP$parser$result; + + /* select the action based on the action number */ + switch (CUP$parser$act_num) + { + /*. . . . . . . . . . . . . . . . . . . .*/ + case 56: // RelOp ::= _SYMB_14 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGeC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 55: // RelOp ::= _SYMB_13 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLeC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 54: // RelOp ::= _SYMB_12 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpLtC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 53: // RelOp ::= _SYMB_11 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpNeC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 52: // RelOp ::= _SYMB_10 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpEqC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 51: // RelOp ::= _SYMB_9 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOpGtC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("RelOp",20, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 50: // BasicExpr3 ::= _SYMB_7 Statement _SYMB_8 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStmtC(p_2); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 49: // BasicExpr3 ::= _SYMB_7 CondExpr _SYMB_8 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ECondExprC(p_2); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 48: // BasicExpr3 ::= QDouble + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EDblC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 47: // BasicExpr3 ::= QInteger + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIntC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 46: // BasicExpr3 ::= _STRING_ + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EStrC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 45: // BasicExpr3 ::= QIdent _SYMB_7 ListCondExpr _SYMB_8 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-3)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EFunC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 44: // BasicExpr3 ::= QIdent + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EIdentC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 43: // BasicExpr3 ::= QBool + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + String p_1 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.EBoolC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr3",19, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 42: // BasicExpr2 ::= BasicExpr3 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_1; + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr2",18, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 41: // BasicExpr2 ::= _SYMB_3 BasicExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprNegC(p_2); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr2",18, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 40: // BasicExpr1 ::= BasicExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_1; + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr1",17, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 39: // BasicExpr1 ::= BasicExpr1 _SYMB_6 BasicExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprModC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr1",17, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 38: // BasicExpr1 ::= BasicExpr1 _SYMB_5 BasicExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprDivC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr1",17, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 37: // BasicExpr1 ::= BasicExpr1 _SYMB_4 BasicExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprMulC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr1",17, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 36: // BasicExpr ::= BasicExpr1 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_1; + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr",16, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 35: // BasicExpr ::= BasicExpr _SYMB_3 BasicExpr1 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprSubC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr",16, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 34: // BasicExpr ::= BasicExpr _SYMB_2 BasicExpr1 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExprAddC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BasicExpr",16, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 33: // CondExpr2 ::= BoolExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprBoolExprC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr2",15, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 32: // CondExpr2 ::= _SYMB_22 CondExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprNotC(p_2); + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr2",15, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 31: // CondExpr1 ::= CondExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_1; + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr1",14, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 30: // CondExpr1 ::= CondExpr1 _SYMB_15 CondExpr2 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprAndC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr1",14, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 29: // CondExpr ::= CondExpr1 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_1; + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr",13, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 28: // CondExpr ::= CondExpr _SYMB_24 CondExpr1 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExprOrC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("CondExpr",13, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 27: // BoolExpr ::= BasicExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprBasicExprC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BoolExpr",12, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 26: // BoolExpr ::= BasicExpr _SYMB_26 _STRING_ + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + String p_3 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprRegExpC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BoolExpr",12, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 25: // BoolExpr ::= BasicExpr RelOp BasicExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.RelOp)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BasicExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.BoolExprCmpC(p_1,p_2,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("BoolExpr",12, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 24: // SelItem ::= CondExpr _SYMB_16 QIdent + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + String p_3 = (String)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AliasedSelItemC(p_1,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("SelItem",11, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 23: // SelItem ::= CondExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItemC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("SelItem",11, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 22: // Nulls ::= _SYMB_23 _SYMB_21 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullsLastC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Nulls",10, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 21: // Nulls ::= _SYMB_23 _SYMB_20 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NullFirstsC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Nulls",10, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 20: // Nulls ::= + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoNullsC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Nulls",10, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 19: // Order ::= + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Order",9, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 18: // Order ::= _SYMB_19 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.DescOrderC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Order",9, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 17: // Order ::= _SYMB_17 + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.AscOrderC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Order",9, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 16: // OrderItem ::= CondExpr Order Nulls + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Order)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Nulls)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItemC(p_1,p_2,p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("OrderItem",8, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 15: // OrderBy ::= _SYMB_25 _SYMB_18 ListOrderItem + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderByC(p_3); + CUP$parser$result = parser.getSymbolFactory().newSymbol("OrderBy",7, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 14: // OrderBy ::= + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoOrderByC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("OrderBy",7, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 13: // Where ::= _SYMB_28 CondExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.WhereC(p_2); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Where",6, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 12: // Where ::= + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.NoWhereC(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Where",6, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 11: // Statement ::= _SYMB_27 ListSelItem Where OrderBy + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem p_2 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Where)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy p_4 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderBy)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.StatementC(p_2,p_3,p_4); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Statement",5, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 10: // Program ::= ListStatement + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ProgramC(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("Program",4, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 9: // ListCondExpr ::= CondExpr _SYMB_1 ListCondExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_3; p_3.addFirst(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListCondExpr",3, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 8: // ListCondExpr ::= CondExpr + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.CondExpr)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr(); RESULT.addLast(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListCondExpr",3, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 7: // ListCondExpr ::= + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr RESULT =null; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListCondExpr(); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListCondExpr",3, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 6: // ListSelItem ::= SelItem _SYMB_1 ListSelItem + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_3; p_3.addFirst(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListSelItem",2, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 5: // ListSelItem ::= SelItem + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.SelItem)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListSelItem(); RESULT.addLast(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListSelItem",2, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 4: // ListOrderItem ::= OrderItem _SYMB_1 ListOrderItem + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_3; p_3.addFirst(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListOrderItem",1, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 3: // ListOrderItem ::= OrderItem + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.OrderItem)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListOrderItem(); RESULT.addLast(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListOrderItem",1, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 2: // ListStatement ::= Statement _SYMB_0 ListStatement + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-2)).value; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement p_3 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = p_3; p_3.addFirst(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListStatement",0, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 1: // ListStatement ::= Statement + { + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement p_1 = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Statement)((java_cup.runtime.Symbol) CUP$parser$stack.peek()).value; + RESULT = new pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.ListStatement(); RESULT.addLast(p_1); + CUP$parser$result = parser.getSymbolFactory().newSymbol("ListStatement",0, RESULT); + } + return CUP$parser$result; + + /*. . . . . . . . . . . . . . . . . . . .*/ + case 0: // $START ::= Program EOF + { + Object RESULT =null; + pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program start_val = (pl.edu.mimuw.cloudatlas.interpreter.query.Absyn.Program)((java_cup.runtime.Symbol) CUP$parser$stack.elementAt(CUP$parser$top-1)).value; + RESULT = start_val; + CUP$parser$result = parser.getSymbolFactory().newSymbol("$START",0, RESULT); + } + /* ACCEPT */ + CUP$parser$parser.done_parsing(); + return CUP$parser$result; + + /* . . . . . .*/ + default: + throw new Exception( + "Invalid action number found in internal parse table"); + + } + } +} + diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/query.cup b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/query.cup new file mode 100644 index 0000000..6460d78 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/query.cup @@ -0,0 +1,169 @@ +// -*- Java -*- This Cup file was machine-generated by BNFC +package pl.edu.mimuw.mmws.cloudatlas.query; + +parser code {: + public pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Program pProgram() throws Exception + { + java_cup.runtime.Symbol res = parse(); + return (pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Program) res.value; + } + +public <B,A extends java.util.LinkedList<? super B>> A cons_(B x, A xs) { xs.addFirst(x); return xs; } + +public void syntax_error(java_cup.runtime.Symbol cur_token) +{ + report_error("Syntax Error, trying to recover and continue parse...", cur_token); +} + +public void unrecovered_syntax_error(java_cup.runtime.Symbol cur_token) throws java.lang.Exception +{ + throw new Exception("Unrecoverable Syntax Error"); +} + +:} + +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListStatement ListStatement; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListOrderItem ListOrderItem; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListSelItem ListSelItem; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListCondExpr ListCondExpr; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Program Program; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Statement Statement; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Where Where; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.OrderBy OrderBy; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.OrderItem OrderItem; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Order Order; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.Nulls Nulls; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.SelItem SelItem; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BoolExpr BoolExpr; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExpr CondExpr; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExpr CondExpr1; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExpr CondExpr2; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExpr BasicExpr; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExpr BasicExpr1; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExpr BasicExpr2; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExpr BasicExpr3; +nonterminal pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOp RelOp; + +terminal _SYMB_0; // ; +terminal _SYMB_1; // , +terminal _SYMB_2; // + +terminal _SYMB_3; // - +terminal _SYMB_4; // * +terminal _SYMB_5; // / +terminal _SYMB_6; // % +terminal _SYMB_7; // ( +terminal _SYMB_8; // ) +terminal _SYMB_9; // > +terminal _SYMB_10; // = +terminal _SYMB_11; // <> +terminal _SYMB_12; // < +terminal _SYMB_13; // <= +terminal _SYMB_14; // >= +terminal _SYMB_15; // AND +terminal _SYMB_16; // AS +terminal _SYMB_17; // ASC +terminal _SYMB_18; // BY +terminal _SYMB_19; // DESC +terminal _SYMB_20; // FIRST +terminal _SYMB_21; // LAST +terminal _SYMB_22; // NOT +terminal _SYMB_23; // NULLS +terminal _SYMB_24; // OR +terminal _SYMB_25; // ORDER +terminal _SYMB_26; // REGEXP +terminal _SYMB_27; // SELECT +terminal _SYMB_28; // WHERE + +terminal String _STRING_; + + + + + +terminal String QBool; +terminal String QIdent; +terminal String QDouble; +terminal String QInteger; + + +start with Program; + + +ListStatement ::= Statement:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListStatement(); RESULT.addLast(p_1); :} + | Statement:p_1 _SYMB_0 ListStatement:p_3 {: RESULT = p_3; p_3.addFirst(p_1); :} +; +ListOrderItem ::= OrderItem:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListOrderItem(); RESULT.addLast(p_1); :} + | OrderItem:p_1 _SYMB_1 ListOrderItem:p_3 {: RESULT = p_3; p_3.addFirst(p_1); :} +; +ListSelItem ::= SelItem:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListSelItem(); RESULT.addLast(p_1); :} + | SelItem:p_1 _SYMB_1 ListSelItem:p_3 {: RESULT = p_3; p_3.addFirst(p_1); :} +; +ListCondExpr ::= /* empty */ {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListCondExpr(); :} + | CondExpr:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ListCondExpr(); RESULT.addLast(p_1); :} + | CondExpr:p_1 _SYMB_1 ListCondExpr:p_3 {: RESULT = p_3; p_3.addFirst(p_1); :} +; +Program ::= ListStatement:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ProgramC(p_1); :} +; +Statement ::= _SYMB_27 ListSelItem:p_2 Where:p_3 OrderBy:p_4 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.StatementC(p_2,p_3,p_4); :} +; +Where ::= /* empty */ {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NoWhereC(); :} + | _SYMB_28 CondExpr:p_2 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.WhereC(p_2); :} +; +OrderBy ::= /* empty */ {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NoOrderByC(); :} + | _SYMB_25 _SYMB_18 ListOrderItem:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.OrderByC(p_3); :} +; +OrderItem ::= CondExpr:p_1 Order:p_2 Nulls:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.OrderItemC(p_1,p_2,p_3); :} +; +Order ::= _SYMB_17 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.AscOrderC(); :} + | _SYMB_19 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.DescOrderC(); :} + | /* empty */ {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NoOrderC(); :} +; +Nulls ::= /* empty */ {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NoNullsC(); :} + | _SYMB_23 _SYMB_20 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NullFirstsC(); :} + | _SYMB_23 _SYMB_21 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.NullsLastC(); :} +; +SelItem ::= CondExpr:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.SelItemC(p_1); :} + | CondExpr:p_1 _SYMB_16 QIdent:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.AliasedSelItemC(p_1,p_3); :} +; +BoolExpr ::= BasicExpr:p_1 RelOp:p_2 BasicExpr:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BoolExprCmpC(p_1,p_2,p_3); :} + | BasicExpr:p_1 _SYMB_26 _STRING_:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BoolExprRegExpC(p_1,p_3); :} + | BasicExpr:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BoolExprBasicExprC(p_1); :} +; +CondExpr ::= CondExpr:p_1 _SYMB_24 CondExpr1:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExprOrC(p_1,p_3); :} + | CondExpr1:p_1 {: RESULT = p_1; :} +; +CondExpr1 ::= CondExpr1:p_1 _SYMB_15 CondExpr2:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExprAndC(p_1,p_3); :} + | CondExpr2:p_1 {: RESULT = p_1; :} +; +CondExpr2 ::= _SYMB_22 CondExpr2:p_2 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExprNotC(p_2); :} + | BoolExpr:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.CondExprBoolExprC(p_1); :} +; +BasicExpr ::= BasicExpr:p_1 _SYMB_2 BasicExpr1:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprAddC(p_1,p_3); :} + | BasicExpr:p_1 _SYMB_3 BasicExpr1:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprSubC(p_1,p_3); :} + | BasicExpr1:p_1 {: RESULT = p_1; :} +; +BasicExpr1 ::= BasicExpr1:p_1 _SYMB_4 BasicExpr2:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprMulC(p_1,p_3); :} + | BasicExpr1:p_1 _SYMB_5 BasicExpr2:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprDivC(p_1,p_3); :} + | BasicExpr1:p_1 _SYMB_6 BasicExpr2:p_3 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprModC(p_1,p_3); :} + | BasicExpr2:p_1 {: RESULT = p_1; :} +; +BasicExpr2 ::= _SYMB_3 BasicExpr2:p_2 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.BasicExprNegC(p_2); :} + | BasicExpr3:p_1 {: RESULT = p_1; :} +; +BasicExpr3 ::= QBool:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EBoolC(p_1); :} + | QIdent:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EIdentC(p_1); :} + | QIdent:p_1 _SYMB_7 ListCondExpr:p_3 _SYMB_8 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EFunC(p_1,p_3); :} + | _STRING_:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EStrC(p_1); :} + | QInteger:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EIntC(p_1); :} + | QDouble:p_1 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EDblC(p_1); :} + | _SYMB_7 CondExpr:p_2 _SYMB_8 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.ECondExprC(p_2); :} + | _SYMB_7 Statement:p_2 _SYMB_8 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.EStmtC(p_2); :} +; +RelOp ::= _SYMB_9 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpGtC(); :} + | _SYMB_10 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpEqC(); :} + | _SYMB_11 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpNeC(); :} + | _SYMB_12 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpLtC(); :} + | _SYMB_13 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpLeC(); :} + | _SYMB_14 {: RESULT = new pl.edu.mimuw.mmws.cloudatlas.query.Absyn.RelOpGeC(); :} +; + diff --git a/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/sym.java b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/sym.java new file mode 100644 index 0000000..34b6cc7 --- /dev/null +++ b/src/main/java/pl/edu/mimuw/cloudatlas/interpreter/query/sym.java @@ -0,0 +1,49 @@ + +//---------------------------------------------------- +// The following code was generated by CUP v0.11a beta 20060608 +// Sat Nov 16 17:39:43 CET 2013 +//---------------------------------------------------- + +package pl.edu.mimuw.cloudatlas.interpreter.query; + +/** CUP generated class containing symbol constants. */ +public class sym { + /* terminals */ + public static final int _SYMB_18 = 20; + public static final int _SYMB_17 = 19; + public static final int _SYMB_16 = 18; + public static final int _SYMB_15 = 17; + public static final int _SYMB_14 = 16; + public static final int _SYMB_13 = 15; + public static final int QIdent = 33; + public static final int _SYMB_12 = 14; + public static final int _SYMB_11 = 13; + public static final int _SYMB_9 = 11; + public static final int _SYMB_8 = 10; + public static final int _SYMB_10 = 12; + public static final int _SYMB_7 = 9; + public static final int _SYMB_6 = 8; + public static final int _SYMB_5 = 7; + public static final int _SYMB_4 = 6; + public static final int _SYMB_3 = 5; + public static final int _SYMB_2 = 4; + public static final int _SYMB_1 = 3; + public static final int _SYMB_0 = 2; + public static final int QDouble = 34; + public static final int _STRING_ = 31; + public static final int EOF = 0; + public static final int error = 1; + public static final int _SYMB_28 = 30; + public static final int _SYMB_27 = 29; + public static final int _SYMB_26 = 28; + public static final int _SYMB_25 = 27; + public static final int QBool = 32; + public static final int _SYMB_24 = 26; + public static final int _SYMB_23 = 25; + public static final int _SYMB_22 = 24; + public static final int _SYMB_21 = 23; + public static final int _SYMB_20 = 22; + public static final int QInteger = 35; + public static final int _SYMB_19 = 21; +} + |