@Override
public Result<IValue> fieldSelect(Field[] selectedFields) {
int nFields = selectedFields.length;
int fieldIndices[] = new int[nFields];
Type baseType = this.getType();
for (int i = 0; i < nFields; i++) {
Field f = selectedFields[i];
if (f.isIndex()) {
fieldIndices[i] =
((IInteger) f.getFieldIndex().interpret(this.ctx.getEvaluator()).getValue()).intValue();
} else {
String fieldName = org.rascalmpl.interpreter.utils.Names.name(f.getFieldName());
try {
fieldIndices[i] = baseType.getFieldIndex(fieldName);
} catch (UndeclaredFieldException e) {
throw new UndeclaredFieldError(fieldName, baseType, ctx.getCurrentAST());
}
}
if (fieldIndices[i] < 0 || fieldIndices[i] > baseType.getArity()) {
throw org.rascalmpl.interpreter.utils.RuntimeExceptionFactory.indexOutOfBounds(
ValueFactoryFactory.getValueFactory().integer(fieldIndices[i]),
ctx.getCurrentAST(),
ctx.getStackTrace());
}
}
return this.fieldSelect(fieldIndices);
}
private void checkRecord(Type eltType, Record record, IEvaluatorContext ctx) {
// TODO: not all inconsistencies are detected yet
// probably because absent values get type void
// but are nevertheless initialized eventually
// to 0, false, or "".
if (record.getType().isSubtypeOf(eltType)) {
return;
}
if (eltType.isTuple()) {
int expectedArity = eltType.getArity();
int actualArity = record.getType().getArity();
if (expectedArity == actualArity) {
return;
}
throw RuntimeExceptionFactory.illegalTypeArgument(
"Arities of actual type and requested type are different ("
+ actualArity
+ " vs "
+ expectedArity
+ ")",
ctx.getCurrentAST(),
ctx.getStackTrace());
}
throw RuntimeExceptionFactory.illegalTypeArgument(
"Invalid tuple " + record + " for requested field " + eltType,
ctx.getCurrentAST(),
ctx.getStackTrace());
}
public ISet intersect(ISet other) {
ShareableValuesHashSet commonData = new ShareableValuesHashSet();
Iterator<IValue> setIterator;
ISet theOtherSet;
if (other.size() <= size()) {
setIterator = other.iterator();
theOtherSet = this;
} else {
setIterator = iterator();
theOtherSet = other;
}
Type newElementType = TypeFactory.getInstance().voidType();
while (setIterator.hasNext()) {
IValue value = setIterator.next();
if (theOtherSet.contains(value)) {
newElementType = newElementType.lub(value.getType());
commonData.add(value);
}
}
return new SetWriter(newElementType, commonData).done();
}
@Override
protected <U extends IValue> Result<U> joinRelation(RelationResult that) {
// Note the reverse of arguments, we need "that join this"
int arity1 = that.getValue().arity();
Type eltType = getType().getElementType();
Type tupleType = that.getType().getElementType();
Type fieldTypes[] = new Type[arity1 + 1];
for (int i = 0; i < arity1; i++) {
fieldTypes[i] = tupleType.getFieldType(i);
}
fieldTypes[arity1] = eltType;
Type resultTupleType = getTypeFactory().tupleType(fieldTypes);
ISetWriter writer = getValueFactory().setWriter(resultTupleType);
IValue fieldValues[] = new IValue[arity1 + 1];
for (IValue relValue : that.getValue()) {
for (IValue setValue : this.getValue()) {
for (int i = 0; i < arity1; i++) {
fieldValues[i] = ((ITuple) relValue).get(i);
}
fieldValues[arity1] = setValue;
writer.insert(getValueFactory().tuple(fieldValues));
}
}
Type resultType = getTypeFactory().relTypeFromTuple(resultTupleType);
return makeResult(resultType, writer.done(), ctx);
}
public IList getProfileData() {
TypeFactory TF = TypeFactory.getInstance();
Type elemType = TF.tupleType(TF.sourceLocationType(), TF.integerType());
Type listType = TF.listType(elemType);
IValueFactory VF = ValueFactoryFactory.getValueFactory();
IListWriter w = listType.writer(VF);
for (Map.Entry<AbstractAST, Count> e : sortData()) {
w.insert(VF.tuple(e.getKey().getLocation(), VF.integer(e.getValue().getTicks())));
}
return w.done();
}
public ISet subtract(ISet other) {
ShareableValuesHashSet newData = new ShareableValuesHashSet(data);
Iterator<IValue> setIterator = other.iterator();
while (setIterator.hasNext()) {
newData.remove(setIterator.next());
}
Type newElementType = TypeFactory.getInstance().voidType();
for (IValue el : newData) newElementType = newElementType.lub(el.getType());
return new SetWriter(newElementType, newData).done();
}
public ISet delete(IValue value) {
if (contains(value)) {
ShareableValuesHashSet newData = new ShareableValuesHashSet(data);
newData.remove(value);
Type newElementType = TypeFactory.getInstance().voidType();
for (IValue el : newData) {
newElementType = newElementType.lub(el.getType());
}
return new SetWriter(newElementType, newData).done();
} else {
return this;
}
}
/**
* @param fieldTypes as inferred for the whole relation.
* @return The tuple value for this record
*/
ITuple getTuple(Type fieldTypes) {
IValue fieldValues[] = new IValue[rfields.size()];
for (int i = 0; i < rfields.size(); i++) {
if (rfields.get(i) == null) {
if (fieldTypes.getFieldType(i).isBool()) rfields.set(i, values.bool(false));
else if (fieldTypes.getFieldType(i).isInteger()) rfields.set(i, values.integer(0));
else if (fieldTypes.getFieldType(i).isReal()) rfields.set(i, values.real(0));
else rfields.set(i, values.string(""));
}
if (fieldTypes.getFieldType(i).isString() && !rfields.get(i).getType().isString())
rfields.set(i, values.string(rfields.get(i).toString()));
fieldValues[i] = rfields.get(i);
}
return values.tuple(fieldValues);
}
/* (non-Javadoc)
* @see org.rascalmpl.tasks.ITaskRegistry#getProducer(Type, IValue)
*/
@Override
public ITask<Type, IValue, IValue> getProducer(Type key, IValue name) {
lock.lock();
try {
Map<Type, ITask<Type, IValue, IValue>> producerMap = keyedProducers.get(key);
if (producerMap != null) {
Type nameType = name.getType();
if (producerMap.containsKey(nameType)) return producerMap.get(nameType);
for (Map.Entry<Type, ITask<Type, IValue, IValue>> t : producerMap.entrySet()) {
if (nameType.isSubtypeOf(t.getKey())) return t.getValue();
}
}
throw new ImplementationError("No suitable producer found for " + key + "(" + name + ")");
} finally {
lock.unlock();
}
}
public IValue buildCollection(Type type, List<Record> records, IEvaluatorContext ctx) {
IWriter writer;
while (type.isAliased()) {
type = type.getAliased();
}
if (type.isList()) {
writer = values.listWriter(type.getElementType());
} else if (type.isRelation()) {
writer = values.relationWriter(type.getElementType());
} else {
throw RuntimeExceptionFactory.illegalTypeArgument(
"Invalid result type for CSV reading: " + type, ctx.getCurrentAST(), ctx.getStackTrace());
}
// reverse traversal so that the order in case of ListWriter is correct
// (IWriter only supports inserts at the front).
Type eltType = type.getElementType();
for (int i = records.size() - 1; i >= 0; i--) {
Record record = records.get(i);
checkRecord(eltType, record, ctx);
writer.insert(record.getTuple(eltType));
}
return writer.done();
}
@Override
public <U extends IValue, V extends IValue> Result<U> fieldUpdate(
String name, Result<V> repl, TypeStore store) {
if (!getType().hasFieldNames()) {
throw new UndeclaredFieldError(name, getType(), ctx.getCurrentAST());
}
try {
int index = getType().getFieldIndex(name);
Type type = getType().getFieldType(index);
if (!type.isSubtypeOf(repl.getType())) {
throw new UnexpectedTypeError(type, repl.getType(), ctx.getCurrentAST());
}
return makeResult(getType(), getValue().set(index, repl.getValue()), ctx);
} catch (UndeclaredFieldException e) {
throw new UndeclaredFieldError(name, getType(), ctx.getCurrentAST());
}
}
public void testIntersectISet() {
ISet empty1 = vf.set(tf.tupleType(tf.integerType()));
ISet empty2 = vf.set(tf.tupleType(tf.realType()));
try {
final ISet intersection = empty1.intersect(empty2);
if (!intersection.isEmpty()) {
fail("empty intersection failed");
}
Type type = intersection.getType();
if (!type.getFieldType(0).isSubtypeOf(tf.numberType())) {
fail("intersection should produce lub types");
}
} catch (FactTypeUseException e) {
fail("intersecting types which have a lub should be possible");
}
try {
if (!integerRelation.intersect(doubleRelation).isEmpty()) {
fail("non-intersecting relations should produce empty intersections");
}
ISet oneTwoThree = vf.set(integerTuples[0], integerTuples[1], integerTuples[2]);
ISet threeFourFive = vf.set(integerTuples[2], integerTuples[3], integerTuples[4]);
ISet result = vf.set(integerTuples[2]);
if (!oneTwoThree.intersect(threeFourFive).isEqual(result)) {
fail("intersection failed");
}
if (!threeFourFive.intersect(oneTwoThree).isEqual(result)) {
fail("intersection should be commutative");
}
if (!oneTwoThree
.intersect(vf.set(tf.tupleType(tf.integerType(), tf.integerType())))
.isEmpty()) {
fail("intersection with empty set should produce empty");
}
} catch (FactTypeUseException e) {
fail("the above should all be type safe");
}
}
/* (non-Javadoc)
* @see org.rascalmpl.tasks.ITaskRegistry#registerProducer(org.rascalmpl.tasks.ITask)
*/
@Override
public void registerProducer(ITask<Type, IValue, IValue> producer) {
lock.lock();
try {
for (Type key : producer.getKeys()) {
if (key.isTuple()) {
Type key1 = key.getFieldType(0);
Type key2 = key.getFieldType(1);
Map<Type, ITask<Type, IValue, IValue>> map = keyedProducers.get(key1);
if (map == null) map = new HashMap<Type, ITask<Type, IValue, IValue>>();
map.put(key2, producer);
keyedProducers.put(key1, map);
} else {
producers.put(key, producer);
}
}
} finally {
lock.unlock();
}
}
public ISet insert(IValue value) {
if (!contains(value)) {
ShareableValuesHashSet newData = new ShareableValuesHashSet(data);
newData.add(value);
Type type = elementType.lub(value.getType());
return new SetWriter(type, newData).done();
} else {
return this;
}
}
@Override
public Type getType(Environment env, HashMap<String, IVarPattern> patternVars) {
if (patternSize == 0) {
return tf.listType(tf.voidType());
}
Type elemType = tf.voidType();
for (int i = 0; i < patternSize; i += delta) {
IMatchingResult child = patternChildren.get(i);
Type childType = child.getType(env, patternVars);
patternVars = merge(patternVars, patternChildren.get(i).getVariables());
boolean isMultiVar =
child instanceof MultiVariablePattern || child instanceof TypedMultiVariablePattern;
if (childType.isList() && isMultiVar) {
elemType = elemType.lub(childType.getElementType());
} else {
elemType = elemType.lub(childType);
}
}
if (debug) {
System.err.println("ListPattern.getType: " + tf.listType(elemType));
}
return tf.listType(elemType);
}
public void generateTypedInterfaceInternal(
IString tag, ISourceLocation uriLoc, IEvaluatorContext ctx) {
IResource handler = Resource.getResourceHandler(uriLoc);
String tagStr = tag.getValue();
Type t = handler.getResourceType(ctx, uriLoc);
PrintWriter currentOutStream = ctx.getStdOut();
// Declare an alias to the type of the resource
TypeStore ts = ctx.getCurrentEnvt().getStore();
Type alias2t = TypeFactory.getInstance().aliasType(ts, tagStr + "Type", t);
currentOutStream.println(
"Generated type alias " + alias2t.toString() + ": " + alias2t.getAliased().toString());
currentOutStream.flush();
// Declare a function that just uses the given URI. This way, if we provide
// the complete URI up front, we don't need to keep providing it later.
StringBuilder sb = new StringBuilder();
sb.append("public ").append(tagStr).append("Type ").append(tagStr).append("() { ");
sb.append(" return getTypedResource(")
.append(uriLoc.toString())
.append(",#")
.append(tagStr)
.append("Type); }");
IConstructor declTree =
ctx.getEvaluator()
.parseCommand(
ctx.getEvaluator().getMonitor(),
sb.toString(),
ctx.getCurrentAST().getLocation().getURI());
Command cmd = ctx.getEvaluator().getBuilder().buildCommand(declTree);
Environment env = ctx.getCurrentEnvt();
ctx.setCurrentEnvt(env.getRoot());
Result<IValue> fun0 = ctx.getEvaluator().eval(ctx.getEvaluator().getMonitor(), cmd);
ctx.unwind(env);
currentOutStream.println("Generated function " + fun0.toString());
currentOutStream.flush();
}
@Override
public Type typeOf(Environment __eval) {
String name;
Type type = null;
Environment theEnv = __eval.getHeap().getEnvironmentForName(this.getName(), __eval);
name = org.rascalmpl.interpreter.utils.Names.typeName(this.getName());
if (theEnv != null) {
type = theEnv.lookupAlias(name);
if (type == null) {
type = theEnv.lookupAbstractDataType(name);
}
}
if (type != null) {
Map<Type, Type> bindings = new HashMap<Type, Type>();
Type[] params = new Type[this.getParameters().size()];
int i = 0;
for (org.rascalmpl.ast.Type param : this.getParameters()) {
params[i++] = param.typeOf(__eval);
}
// __eval has side-effects that we might need?
type.getTypeParameters().match(TF.tupleType(params), bindings);
// Instantiate first using the type actually given in the parameter,
// e.g., for T[str], with data T[&U] = ..., instantate the binding
// of &U = str, and then instantate using bindings from the current
// environment (generally meaning we are inside a function with
// type parameters, and those parameters are now bound to real types)
return type.instantiate(bindings).instantiate(__eval.getTypeBindings());
}
throw new UndeclaredTypeError(name, this);
}
/* (non-Javadoc)
* @see org.rascalmpl.tasks.ITaskRegistry#produce(org.rascalmpl.interpreter.IRascalMonitor, org.rascalmpl.tasks.ITransaction, Type, IValue)
*/
@Override
public boolean produce(
IRascalMonitor monitor, ITransaction<Type, IValue, IValue> tr, Type key, IValue name) {
ITask<Type, IValue, IValue> producer = null;
lock.lock();
try {
producer = getProducer(key, name);
} finally {
lock.unlock();
}
if (producer == null)
throw new ImplementationError("No registered fact producer for " + key.toString());
return producer.produce(monitor, tr, key, name);
}
/* (non-Javadoc)
* @see org.rascalmpl.tasks.ITaskRegistry#unregisterProducer(org.rascalmpl.tasks.ITask)
*/
@Override
public void unregisterProducer(ITask<Type, IValue, IValue> producer) {
lock.lock();
try {
for (Type key : producer.getKeys()) {
if (key.isTuple()) {
Type key1 = key.getFieldType(0);
Map<Type, ITask<Type, IValue, IValue>> map = keyedProducers.get(key1);
if (map != null) {
for (Map.Entry<Type, ITask<Type, IValue, IValue>> entry : map.entrySet()) {
if (entry.getValue().equals(producer)) map.remove(entry.getKey());
}
if (map.isEmpty()) keyedProducers.remove(key1);
else keyedProducers.put(key1, map);
}
} else {
if (producers.get(key) == producer) producers.remove(key);
}
}
} finally {
lock.unlock();
}
}
@Override
protected <U extends IValue> Result<U> addTuple(TupleResult that) {
// Note reversed args
TupleResult left = that;
TupleResult right = this;
Type leftType = left.getType();
Type rightType = right.getType();
int leftArity = leftType.getArity();
int rightArity = rightType.getArity();
int newArity = leftArity + rightArity;
Type fieldTypes[] = new Type[newArity];
String fieldNames[] = new String[newArity];
IValue fieldValues[] = new IValue[newArity];
boolean consistentLabels = true;
for (int i = 0; i < leftArity; i++) {
fieldTypes[i] = leftType.getFieldType(i);
fieldNames[i] = leftType.getFieldName(i);
fieldValues[i] = left.getValue().get(i);
consistentLabels = fieldNames[i] != null;
}
for (int i = 0; i < rightArity; i++) {
fieldTypes[leftArity + i] = rightType.getFieldType(i);
fieldNames[leftArity + i] = rightType.getFieldName(i);
fieldValues[leftArity + i] = right.getValue().get(i);
consistentLabels = fieldNames[i] != null;
if (consistentLabels) {
for (int j = 0; j < leftArity; j++) {
if (fieldNames[j].equals(fieldNames[i])) {
// duplicate field name, so degenerate to unlabeled tuple
consistentLabels = false;
}
}
}
}
Type newTupleType;
if (consistentLabels) {
newTupleType = getTypeFactory().tupleType(fieldTypes, fieldNames);
} else {
newTupleType = getTypeFactory().tupleType(fieldTypes);
}
return makeResult(newTupleType, getValueFactory().tuple(fieldValues), ctx);
}
public ISet union(ISet other) {
ShareableValuesHashSet newData;
Iterator<IValue> setIterator;
Set otherSet = (Set) other;
if (otherSet.size() <= size()) {
newData = new ShareableValuesHashSet(data);
setIterator = otherSet.iterator();
} else {
newData = new ShareableValuesHashSet(otherSet.data);
setIterator = iterator();
}
while (setIterator.hasNext()) {
newData.add(setIterator.next());
}
Type newElementType = elementType.lub(otherSet.elementType);
return new SetWriter(newElementType, newData).done();
}
private Class<?> toJavaClass(org.eclipse.imp.pdb.facts.type.Type type) {
return type.accept(javaClasses);
}
@Override
public void initMatch(Result<IValue> subject) {
if (debug) {
System.err.println("List: initMatch: subject=" + subject);
}
// This is an experiment to add abstract list matching for concrete subjects
// if (subject.getType().isSubtypeOf(Factory.Tree)) {
// IConstructor tree = (IConstructor) subject.getValue();
// if (TreeAdapter.isList(tree)) {
// subject = ResultFactory.makeResult(Factory.Args, TreeAdapter.getArgs(tree), ctx);
// IConstructor rhs = TreeAdapter.getType(tree);
//
// if (SymbolAdapter.isIterPlusSeps(rhs) || SymbolAdapter.isIterStarSeps(rhs)) {
// this.delta = SymbolAdapter.getSeparators(rhs).length() + 1;
// }
// }
// else {
// hasNext = false;
// return;
// }
// }
super.initMatch(subject);
if (!subject.getValue().getType().isList()) {
hasNext = false;
return;
}
listSubject = (IList) subject.getValue();
listSubjectType = listSubject.getType();
staticListSubjectType = subject.getType();
staticListSubjectElementType =
staticListSubjectType.isList() ? subject.getType().getElementType() : tf.valueType();
subjectCursor = 0;
patternCursor = 0;
subjectSize = ((IList) subject.getValue()).length();
reducedSubjectSize = (subjectSize + delta - 1) / delta;
if (debug) {
System.err.println("reducedPatternSize=" + reducedPatternSize);
System.err.println("reducedSubjectSize=" + reducedSubjectSize);
}
isListVar = new boolean[patternSize];
isBindingVar = new boolean[patternSize];
varName = new String[patternSize];
allVars = new HashSet<String>();
listVarStart = new int[patternSize];
listVarLength = new int[patternSize];
listVarMinLength = new int[patternSize];
listVarMaxLength = new int[patternSize];
listVarOccurrences = new int[patternSize];
int nListVar = 0;
/*
* Pass #1: determine the list variables
*/
for (int i = 0; i < patternSize; i += delta) {
IMatchingResult child = patternChildren.get(i);
isListVar[i] = false;
isBindingVar[i] = false;
Environment env = ctx.getCurrentEnvt();
if (child instanceof TypedMultiVariablePattern) {
TypedMultiVariablePattern tmvVar = (TypedMultiVariablePattern) child;
Type tmvType = tmvVar.getType(env, null);
String name = tmvVar.getName();
varName[i] = name;
isListVar[i] = true;
listVarOccurrences[i] = 1;
++nListVar;
if (!tmvVar.isAnonymous() && allVars.contains(name)) {
throw new RedeclaredVariable(name, getAST());
} else if (tmvType.comparable(listSubject.getType().getElementType())
|| (tmvVar.bindingInstance() && tmvType.comparable(listSubject.getType()))) {
tmvVar.convertToListType();
if (!tmvVar.isAnonymous()) {
allVars.add(name);
}
isBindingVar[i] = true;
} else {
hasNext = false;
return;
}
} else if (child instanceof MultiVariablePattern) {
MultiVariablePattern multiVar = (MultiVariablePattern) child;
String name = multiVar.getName();
varName[i] = name;
isListVar[i] = true;
nListVar++;
if (!multiVar.isAnonymous() && allVars.contains(name)) {
isBindingVar[i] = false;
} else if (multiVar.isAnonymous()) {
isBindingVar[i] = true;
} else {
allVars.add(name);
Result<IValue> varRes = env.getVariable(name);
if (varRes == null || multiVar.bindingInstance()) {
isBindingVar[i] = true;
} else {
isBindingVar[i] = false;
Type varType = varRes.getType();
if (isAnyListType(varType)) {
if (!varType.comparable(listSubjectType)) {
hasNext = false;
return;
}
} else {
if (!(varType instanceof NonTerminalType)
&& !(varType.comparable(staticListSubjectElementType))) {
hasNext = false;
return;
}
}
}
}
} else if (child instanceof ConcreteListVariablePattern) {
ConcreteListVariablePattern listVar = (ConcreteListVariablePattern) child;
String name = listVar.getName();
varName[i] = name;
isListVar[i] = true;
if (!listVar.isAnonymous()) allVars.add(name);
isBindingVar[i] = true;
listVarOccurrences[i] = 1;
nListVar++;
} else if (child instanceof QualifiedNamePattern) {
QualifiedNamePattern qualName = (QualifiedNamePattern) child;
String name = qualName.getName();
varName[i] = name;
if (!qualName.isAnonymous() && allVars.contains(name)) {
/*
* A variable that was declared earlier in the pattern
*/
isListVar[i] = true;
nListVar++;
listVarOccurrences[i]++;
} else if (qualName.isAnonymous()) {
/*
* Nothing to do
*/
} else {
Result<IValue> varRes = env.getVariable(name);
if (varRes == null || qualName.bindingInstance()) {
// A completely new non-list variable, nothing to do
} else {
Type varType = varRes.getType();
if (isAnyListType(varType)) {
/*
* A variable declared in the current scope.
*/
if (varType.comparable(listSubjectType)) {
isListVar[i] = true;
isBindingVar[i] = varRes.getValue() == null;
nListVar++;
} else {
hasNext = false;
return;
}
} else {
if (varType instanceof NonTerminalType) {
// suppress comparable test for Nonterminal types
// TODO: this should be done better
} else if (!varType.comparable(staticListSubjectElementType)) {
hasNext = false;
return;
}
}
}
}
} else if (child instanceof VariableBecomesPattern) {
// Nothing to do
} else {
if (debug) {
System.err.println("List: child " + child);
System.err.println("List: child is a" + child.getClass());
}
Type childType = child.getType(env, null);
// TODO: pattern matching should be specialized such that matching appl(prod...)'s does not
// need to use list matching on the fixed arity children of the application of a production
if (!(childType instanceof NonTerminalType)
&& !childType.comparable(staticListSubjectElementType)) {
hasNext = false;
return;
}
java.util.List<IVarPattern> childVars = child.getVariables();
if (!childVars.isEmpty()) {
for (IVarPattern vp : childVars) { // TODO: This does not profit from extra information
allVars.add(vp.name());
}
isListVar[i] = false;
nListVar++;
}
}
}
/*
* Pass #2: assign minimum and maximum length to each list variable
*/
for (int i = 0; i < patternSize; i += delta) {
if (isListVar[i]) {
// TODO: reduce max length according to number of occurrences
listVarMaxLength[i] =
delta * Math.max(reducedSubjectSize - (reducedPatternSize - nListVar), 0);
listVarLength[i] = 0;
listVarMinLength[i] =
delta
* ((nListVar == 1) ? Math.max(reducedSubjectSize - reducedPatternSize - 1, 0) : 0);
if (debug) {
System.err.println(
"listvar " + i + " min= " + listVarMinLength[i] + " max=" + listVarMaxLength[i]);
}
}
}
firstMatch = true;
hasNext =
subject.getValue().getType().isList()
&& reducedSubjectSize >= reducedPatternSize - nListVar;
if (debug) {
System.err.println("List: hasNext=" + hasNext);
}
}
public static boolean isAnyListType(Type type) {
return type.isList() || isConcreteListType(type);
}
public void write(IValue rel, ISourceLocation loc, IEvaluatorContext ctx) {
OutputStream out = null;
Type paramType = ctx.getCurrentEnvt().getTypeBindings().get(types.parameterType("T"));
if (!paramType.isRelation() && !paramType.isListRelation()) {
throw RuntimeExceptionFactory.illegalTypeArgument(
"A relation type is required instead of " + paramType,
ctx.getCurrentAST(),
ctx.getStackTrace());
}
try {
boolean isListRel = rel instanceof IList;
out = ctx.getResolverRegistry().getOutputStream(loc.getURI(), false);
ISet irel = null;
IList lrel = null;
if (isListRel) {
lrel = (IList) rel;
} else {
irel = (ISet) rel;
}
int nfields = isListRel ? lrel.asRelation().arity() : irel.asRelation().arity();
if (header) {
for (int i = 0; i < nfields; i++) {
if (i > 0) out.write(separator);
String label = paramType.getFieldName(i);
if (label == null || label.isEmpty()) label = "field" + i;
writeString(out, label);
}
out.write('\n');
}
String separatorAsString = new String(Character.toChars(separator));
for (IValue v : (isListRel ? lrel : irel)) {
ITuple tup = (ITuple) v;
int sep = 0;
for (IValue w : tup) {
if (sep == 0) sep = separator;
else out.write(sep);
if (w.getType().isString()) {
String s = ((IString) w).getValue();
if (s.contains(separatorAsString)
|| s.contains("\n")
|| s.contains("\r")
|| s.contains("\"")) {
s = s.replaceAll("\"", "\"\"");
out.write('"');
writeString(out, s);
out.write('"');
} else writeString(out, s);
} else {
writeString(out, w.toString());
}
}
out.write('\n');
}
out.flush();
out.close();
} catch (IOException e) {
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
} finally {
if (out != null) {
try {
out.flush();
out.close();
} catch (IOException ioex) {
throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
}
}
}
}
/**
* UPTR stands for Universal Parse Node Representation (formerly known as AsFix). It is an abstract
* syntax for SDF productions, completed with constructors for parse forests.
*
* <p>UPTR is produced by the SGLR parser, by the ASF+SDF interpreter and by compiled ASF+SDF
* programs. UPTR is consumed by tools that manipulate parse trees in general (such as automatic
* syntax high-lighters) or tools that manipulate specific parse trees (such as the Rascal
* interpreter).
*/
public class Factory {
public static final TypeStore uptr =
new TypeStore(
org.rascalmpl.values.errors.Factory.getStore(),
org.rascalmpl.values.locations.Factory.getStore());
private static final TypeFactory tf = TypeFactory.getInstance();
private static final Type str = tf.stringType();
public static final Type TypeParam = tf.parameterType("T");
public static final Type Type = new ReifiedType(TypeParam);
static {
uptr.declareAbstractDataType(Type);
}
public static final Type Tree = tf.abstractDataType(uptr, "Tree");
public static final Type Production = tf.abstractDataType(uptr, "Production");
public static final Type Attributes = tf.abstractDataType(uptr, "Attributes");
public static final Type Attr = tf.abstractDataType(uptr, "Attr");
public static final Type Associativity = tf.abstractDataType(uptr, "Associativity");
public static final Type Symbol = tf.abstractDataType(uptr, "Symbol");
public static final Type CharRange = tf.abstractDataType(uptr, "CharRange");
public static final Type Args = tf.listType(Tree);
public static final Type Attrs = tf.setType(Attr);
public static final Type Symbols = tf.listType(Symbol);
public static final Type CharRanges = tf.listType(CharRange);
public static final Type Alternatives = tf.setType(Tree);
public static final Type Type_Reified =
tf.constructor(
uptr, Type, "type", Symbol, "symbol", tf.mapType(Symbol, Production), "definitions");
public static final Type Tree_Appl =
tf.constructor(uptr, Tree, "appl", Production, "prod", tf.listType(Tree), "args");
public static final Type Tree_Cycle =
tf.constructor(uptr, Tree, "cycle", Symbol, "symbol", tf.integerType(), "cycleLength");
public static final Type Tree_Amb =
tf.constructor(uptr, Tree, "amb", Alternatives, "alternatives");
public static final Type Tree_Char =
tf.constructor(uptr, Tree, "char", tf.integerType(), "character");
public static final Type Production_Default =
tf.constructor(
uptr,
Production,
"prod",
Symbol,
"def",
tf.listType(Symbol),
"symbols",
tf.setType(Attr),
"attributes");
public static final Type Production_Regular =
tf.constructor(uptr, Production, "regular", Symbol, "def");
public static final Type Production_Error =
tf.constructor(uptr, Production, "error", Production, "prod", tf.integerType(), "dot");
public static final Type Production_Skipped = tf.constructor(uptr, Production, "skipped");
public static final Type Production_Cons =
tf.constructor(
uptr,
Production,
"cons",
Symbol,
"def",
tf.listType(Symbol),
"symbols",
tf.setType(Attr),
"attributes");
public static final Type Production_Func =
tf.constructor(
uptr,
Production,
"func",
Symbol,
"def",
tf.listType(Symbol),
"symbols",
tf.setType(Attr),
"attributes");
public static final Type Production_Choice =
tf.constructor(
uptr, Production, "choice", Symbol, "def", tf.setType(Production), "alternatives");
public static final Type Production_Priority =
tf.constructor(
uptr, Production, "priority", Symbol, "def", tf.listType(Production), "choices");
public static final Type Production_Associativity =
tf.constructor(
uptr,
Production,
"associativity",
Symbol,
"def",
Associativity,
"assoc",
tf.setType(Production),
"alternatives");
public static final Type Attr_Assoc = tf.constructor(uptr, Attr, "assoc", Associativity, "assoc");
public static final Type Attr_Tag = tf.constructor(uptr, Attr, "tag", tf.valueType(), "tag");
public static final Type Attr_Bracket = tf.constructor(uptr, Attr, "bracket");
public static final Type Associativity_Left = tf.constructor(uptr, Associativity, "left");
public static final Type Associativity_Right = tf.constructor(uptr, Associativity, "right");
public static final Type Associativity_Assoc = tf.constructor(uptr, Associativity, "assoc");
public static final Type Associativity_NonAssoc =
tf.constructor(uptr, Associativity, "non-assoc");
public static final Type Condition = tf.abstractDataType(uptr, "Condition");
public static final Type Condition_Follow =
tf.constructor(uptr, Condition, "follow", Symbol, "symbol");
public static final Type Condition_NotFollow =
tf.constructor(uptr, Condition, "not-follow", Symbol, "symbol");
public static final Type Condition_Precede =
tf.constructor(uptr, Condition, "precede", Symbol, "symbol");
public static final Type Condition_NotPrecede =
tf.constructor(uptr, Condition, "not-precede", Symbol, "symbol");
public static final Type Condition_Delete =
tf.constructor(uptr, Condition, "delete", Symbol, "symbol");
public static final Type Condition_EndOfLine = tf.constructor(uptr, Condition, "end-of-line");
public static final Type Condition_StartOfLine = tf.constructor(uptr, Condition, "begin-of-line");
public static final Type Condition_AtColumn =
tf.constructor(uptr, Condition, "at-column", tf.integerType(), "column");
public static final Type Condition_Except =
tf.constructor(uptr, Condition, "except", tf.stringType(), "label");
public static final Type Symbol_Label =
tf.constructor(uptr, Symbol, "label", str, "name", Symbol, "symbol");
public static final Type Symbol_Start_Sort =
tf.constructor(uptr, Symbol, "start", Symbol, "start");
public static final Type Symbol_START = tf.constructor(uptr, Symbol, "START");
public static final Type Symbol_Lit = tf.constructor(uptr, Symbol, "lit", str, "string");
public static final Type Symbol_CiLit = tf.constructor(uptr, Symbol, "cilit", str, "string");
public static final Type Symbol_Empty = tf.constructor(uptr, Symbol, "empty");
public static final Type Symbol_Seq =
tf.constructor(uptr, Symbol, "seq", tf.listType(Symbol), "symbols");
public static final Type Symbol_Opt = tf.constructor(uptr, Symbol, "opt", Symbol, "symbol");
public static final Type Symbol_Alt =
tf.constructor(uptr, Symbol, "alt", tf.setType(Symbol), "alternatives");
public static final Type Symbol_Sort = tf.constructor(uptr, Symbol, "sort", str, "name");
public static final Type Symbol_Lex = tf.constructor(uptr, Symbol, "lex", str, "name");
public static final Type Symbol_Keyword = tf.constructor(uptr, Symbol, "keywords", str, "name");
public static final Type Symbol_Meta = tf.constructor(uptr, Symbol, "meta", Symbol, "symbol");
public static final Type Symbol_Conditional =
tf.constructor(
uptr, Symbol, "conditional", Symbol, "symbol", tf.setType(Condition), "conditions");
public static final Type Symbol_IterSepX =
tf.constructor(
uptr, Symbol, "iter-seps", Symbol, "symbol", tf.listType(Symbol), "separators");
public static final Type Symbol_IterStarSepX =
tf.constructor(
uptr, Symbol, "iter-star-seps", Symbol, "symbol", tf.listType(Symbol), "separators");
public static final Type Symbol_IterPlus = tf.constructor(uptr, Symbol, "iter", Symbol, "symbol");
public static final Type Symbol_IterStar =
tf.constructor(uptr, Symbol, "iter-star", Symbol, "symbol");
public static final Type Symbol_ParameterizedSort =
tf.constructor(
uptr, Symbol, "parameterized-sort", str, "name", tf.listType(Symbol), "parameters");
public static final Type Symbol_Parameter =
tf.constructor(uptr, Symbol, "parameter", str, "name");
public static final Type Symbol_LayoutX = tf.constructor(uptr, Symbol, "layouts", str, "name");
public static final Type Symbol_CharClass =
tf.constructor(uptr, Symbol, "char-class", tf.listType(CharRange), "ranges");
public static final Type Symbol_Int = tf.constructor(uptr, Symbol, "int");
public static final Type Symbol_Rat = tf.constructor(uptr, Symbol, "rat");
public static final Type Symbol_Bool = tf.constructor(uptr, Symbol, "bool");
public static final Type Symbol_Real = tf.constructor(uptr, Symbol, "real");
public static final Type Symbol_Str = tf.constructor(uptr, Symbol, "str");
public static final Type Symbol_Node = tf.constructor(uptr, Symbol, "node");
public static final Type Symbol_Num = tf.constructor(uptr, Symbol, "num");
public static final Type Symbol_Void = tf.constructor(uptr, Symbol, "void");
public static final Type Symbol_Value = tf.constructor(uptr, Symbol, "value");
public static final Type Symbol_Loc = tf.constructor(uptr, Symbol, "loc");
public static final Type Symbol_Datetime = tf.constructor(uptr, Symbol, "datetime");
public static final Type Symbol_Set = tf.constructor(uptr, Symbol, "set", Symbol, "symbol");
public static final Type Symbol_Rel =
tf.constructor(uptr, Symbol, "rel", tf.listType(Symbol), "symbols");
public static final Type Symbol_Tuple =
tf.constructor(uptr, Symbol, "tuple", tf.listType(Symbol), "symbols");
public static final Type Symbol_List = tf.constructor(uptr, Symbol, "list", Symbol, "symbol");
public static final Type Symbol_Map =
tf.constructor(uptr, Symbol, "map", Symbol, "from", Symbol, "to");
public static final Type Symbol_Bag = tf.constructor(uptr, Symbol, "bag", Symbol, "symbol");
public static final Type Symbol_Adt =
tf.constructor(uptr, Symbol, "adt", str, "name", tf.listType(Symbol), "parameters");
public static final Type Symbol_ReifiedType =
tf.constructor(uptr, Symbol, "reified", Symbol, "symbol");
public static final Type Symbol_Func =
tf.constructor(uptr, Symbol, "func", Symbol, "ret", tf.listType(Symbol), "parameters");
public static final Type Symbol_Alias =
tf.constructor(
uptr, Symbol, "alias", str, "name", tf.listType(Symbol), "parameters", Symbol, "aliased");
public static final Type Symbol_Cons =
tf.constructor(
uptr, Symbol, "cons", Symbol, "adt", str, "name", tf.listType(Symbol), "parameters");
public static final Type Symbol_BoundParameter =
tf.constructor(uptr, Symbol, "parameter", str, "name", Symbol, "bound");
public static final Type CharRange_Single =
tf.constructor(uptr, CharRange, "single", tf.integerType(), "begin");
public static final Type CharRange_Range =
tf.constructor(uptr, CharRange, "range", tf.integerType(), "begin", tf.integerType(), "end");
public static final String Location = "loc";
public static final String Length = "len";
private static final IValueFactory vf = ValueFactoryFactory.getValueFactory();
public static final IValue Attribute_Assoc_Left =
Attr_Assoc.make(vf, Associativity_Left.make(vf));
public static final IValue Attribute_Assoc_Right =
Attr_Assoc.make(vf, Associativity_Right.make(vf));
public static final IValue Attribute_Assoc_Non_Assoc =
Attr_Assoc.make(vf, Associativity_NonAssoc.make(vf));
public static final IValue Attribute_Assoc_Assoc =
Attr_Assoc.make(vf, Associativity_Assoc.make(vf));
public static final IValue Attribute_Bracket = Attr_Bracket.make(vf);
private static final class InstanceHolder {
public static final Factory factory = new Factory();
}
public static Factory getInstance() {
return InstanceHolder.factory;
}
private Factory() {
uptr.declareAnnotation(Tree, Location, tf.sourceLocationType());
uptr.declareAnnotation(Tree, Length, tf.integerType());
}
public static TypeStore getStore() {
return uptr;
}
}
@Override
public Class<?> visitAlias(org.eclipse.imp.pdb.facts.type.Type type) {
return type.getAliased().accept(this);
}
@Override
public Class<?> visitParameter(org.eclipse.imp.pdb.facts.type.Type parameterType) {
return parameterType.getBound().accept(this);
}
