private IValue read(Type resultType, ISourceLocation loc, IMap options, IEvaluatorContext ctx) {
setOptions(options);
Reader reader = null;
try {
reader = ctx.getResolverRegistry().getCharacterReader(loc.getURI());
List<Record> records = loadRecords(reader);
if (resultType == null) {
resultType = inferType(records, ctx);
ctx.getStdOut().println("readCSV inferred the relation type: " + resultType);
ctx.getStdOut().flush();
} else if (header) {
records.remove(0);
}
return buildCollection(resultType, records, ctx);
} catch (IOException e) {
throw RuntimeExceptionFactory.io(
values.string(e.getMessage()), ctx.getCurrentAST(), ctx.getStackTrace());
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
throw RuntimeExceptionFactory.io(
values.string(e.getMessage()), ctx.getCurrentAST(), ctx.getStackTrace());
}
}
}
}
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());
}
@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);
}
public IValue nroot(INumber x, IInteger y) {
try {
return x.toReal().nroot(y, values.getPrecision());
} catch (ArithmeticException ae) {
throw RuntimeExceptionFactory.arithmeticException(ae.getMessage(), null, null);
}
}
public IValue pow(INumber x, IInteger y) {
try {
return x.toReal().pow(y);
} catch (ArithmeticException ae) {
throw RuntimeExceptionFactory.arithmeticException(ae.getMessage(), null, null);
}
}
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();
}
private Type inferType(List<Record> records, IEvaluatorContext ctx) throws IOException {
String[] labels = null;
if (header) {
labels = extractLabels(records.remove(0));
}
Type[] fieldTypes = null;
for (Record ri : records) {
List<Type> ftypes = ri.getFieldTypes();
if (fieldTypes == null) {
fieldTypes = new Type[ftypes.size()];
Arrays.fill(fieldTypes, types.voidType());
} else if (ftypes.size() != fieldTypes.length) {
// We assume all records in the CSV file to have the same arity.
throw RuntimeExceptionFactory.illegalArgument(
// "Inconsistent tuple in CSV expected " + fieldTypes.length + " but was " +
// ftypes.size(),
ctx.getCurrentAST(), ctx.getStackTrace());
}
for (int i = 0; i < ftypes.size(); i++) {
fieldTypes[i] = fieldTypes[i].lub(ftypes.get(i));
if (fieldTypes[i].isTop()) {
fieldTypes[i] = types.stringType();
}
}
}
if (labels == null) {
labels = makeUpLabels(fieldTypes.length);
}
return types.setType(types.tupleType(fieldTypes, labels));
}
public IValue readATermFromFile(IString fileName) {
// @doc{readATermFromFile -- read an ATerm from a named file}
ATermReader atr = new ATermReader();
try {
FileInputStream stream = new FileInputStream(fileName.getValue());
IValue result = atr.read(values, stream);
stream.close();
return result;
} catch (FactTypeUseException e) {
e.printStackTrace();
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
} catch (IOException e) {
e.printStackTrace();
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
}
}
@Override
@SuppressWarnings("unchecked")
public <U extends IValue, V extends IValue> Result<U> subscript(Result<?>[] subscripts) {
if (subscripts.length > 1) {
throw new UnsupportedSubscriptArityError(getType(), subscripts.length, ctx.getCurrentAST());
}
Result<IValue> subsBase = (Result<IValue>) subscripts[0];
if (subsBase == null)
/*
* Wild card not allowed as tuple subscript
*/
throw new UnsupportedSubscriptError(type, null, ctx.getCurrentAST());
if (!subsBase.getType().isIntegerType()) {
throw new UnsupportedSubscriptError(
getTypeFactory().integerType(), subsBase.getType(), ctx.getCurrentAST());
}
IInteger index = (IInteger) subsBase.getValue();
if (index.intValue() >= getValue().arity()) {
throw RuntimeExceptionFactory.indexOutOfBounds(
index, ctx.getCurrentAST(), ctx.getStackTrace());
}
Type elementType = getType().getFieldType(index.intValue());
IValue element = getValue().get(index.intValue());
return makeResult(elementType, element, ctx);
}
public IValue log(INumber x, INumber base) {
try {
return x.toReal().log(base.toReal(), values.getPrecision());
} catch (ArithmeticException ae) {
throw RuntimeExceptionFactory.arithmeticException(ae.getMessage(), null, null);
}
}
public IValue uriDecode(IString str) {
try {
return vf.string(URLDecoder.decode(str.getValue(), "UTF-8"));
} catch (UnsupportedEncodingException e) {
throw RuntimeExceptionFactory.illegalArgument(
str, null, null, "UTF-8 is not a valid encoding");
}
}
public void writeTextJSonFile(ISourceLocation loc, IValue value, IEvaluatorContext ctx) {
OutputStream out = null;
try {
out = ctx.getResolverRegistry().getOutputStream(loc.getURI(), false);
new JSonWriter().write(value, new OutputStreamWriter(out, "UTF8"));
} catch (IOException e) {
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
} finally {
if (out != null) {
try {
out.close();
} catch (IOException ioex) {
throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
}
}
}
}
public IValue getLog(IEvaluatorContext e) {
if (logger == null) {
throw RuntimeExceptionFactory.permissionDenied(
vf.string("getLog called before startLog"), e.getCurrentAST(), null);
}
IString result = vf.string(logger.getBuffer().toString());
Evaluator eval = (Evaluator) e;
eval.revertToDefaultWriters();
logger = null;
return result;
}
public IValue readTextJSonFile(IValue type, ISourceLocation loc, IEvaluatorContext ctx) {
// TypeStore store = new TypeStore();
TypeStore store = ctx.getCurrentEnvt().getStore();
Type start = new TypeReifier(ctx.getValueFactory()).valueToType((IConstructor) type, store);
Reader read = null;
try {
read = ctx.getResolverRegistry().getCharacterReader(loc.getURI());
return new JSonReader().read(values, store, start, read);
} catch (IOException e) {
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
} finally {
if (read != null) {
try {
read.close();
} catch (IOException ioex) {
throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
}
}
}
}
public IValue readTextATermFile(IValue type, ISourceLocation loc, IEvaluatorContext ctx) {
TypeStore store = new TypeStore();
Type start = new TypeReifier(ctx.getValueFactory()).valueToType((IConstructor) type, store);
InputStream in = null;
try {
in = ctx.getResolverRegistry().getInputStream(loc.getURI());
return new ATermReader().read(values, store, start, in);
} catch (IOException e) {
throw RuntimeExceptionFactory.io(values.string(e.getMessage()), null, null);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException ioex) {
throw RuntimeExceptionFactory.io(values.string(ioex.getMessage()), null, null);
}
}
}
}
public IValue scale(INumber x) {
try {
if (x.getType().isIntegerType()) {
IInteger k = (IInteger) x;
return values.integer(k.toReal().scale());
}
if (x.getType().isRationalType()) {
IRational k = (IRational) x;
return values.integer(k.toReal().scale());
}
return values.integer(((IReal) x).scale());
} catch (ArithmeticException ae) {
throw RuntimeExceptionFactory.arithmeticException(ae.getMessage(), null, null);
}
}
@Override
public <U extends IValue, V extends IValue> Result<U> fieldUpdate(
String name, Result<V> repl, TypeStore store) {
IConstructor tree = getValue();
if (TreeAdapter.isAppl(tree)) {
int found = -1;
IConstructor foundType = null;
IConstructor prod = TreeAdapter.getProduction(tree);
IList syms = ProductionAdapter.getSymbols(prod);
// TODO: find deeper into optionals, alternatives and sequences checking the actual arguments
// for presence/absence of optional trees.
for (int i = 0; i < syms.length(); i++) {
IConstructor sym = (IConstructor) syms.get(i);
if (SymbolAdapter.isLabel(sym)) {
if (SymbolAdapter.getLabel(sym).equals(name)) {
found = i;
foundType = SymbolAdapter.delabel(sym);
break;
}
}
}
if (found != -1) {
Type nont = RascalTypeFactory.getInstance().nonTerminalType(foundType);
if (repl.getType().isSubtypeOf(nont)) {
IList args = TreeAdapter.getArgs(tree).put(found, repl.getValue());
return makeResult(getType(), tree.set("args", args), ctx);
}
throw new UnexpectedType(nont, repl.getType(), ctx.getCurrentAST());
}
if (Factory.Tree_Appl.hasField(name)) {
Type fieldType = Factory.Tree_Appl.getFieldType(name);
if (repl.getType().isSubtypeOf(fieldType)) {
throw new UnsupportedOperation(
"changing " + name + " in concrete tree", ctx.getCurrentAST());
}
throw new UnexpectedType(fieldType, repl.getType(), ctx.getCurrentAST());
}
throw RuntimeExceptionFactory.noSuchField(name, ctx.getCurrentAST(), ctx.getStackTrace());
}
throw new UnsupportedOperation("field update", ctx.getCurrentAST());
}
@Override
public <U extends IValue> Result<U> fieldAccess(String name, TypeStore store) {
IConstructor tree = getValue();
if (TreeAdapter.isAppl(tree)) {
int found = -1;
IConstructor foundType = null;
IConstructor prod = TreeAdapter.getProduction(tree);
if (!ProductionAdapter.isRegular(prod)) {
IList syms = ProductionAdapter.getSymbols(prod);
// TODO: find deeper into optionals, checking the actual arguments for presence/absence of
// optional trees.
for (int i = 0; i < syms.length(); i++) {
IConstructor sym = (IConstructor) syms.get(i);
while (SymbolAdapter.isConditional(sym)) {
sym = SymbolAdapter.getSymbol(sym);
}
if (SymbolAdapter.isLabel(sym)) {
if (SymbolAdapter.getLabel(sym).equals(name)) {
found = i;
foundType = SymbolAdapter.delabel(sym);
}
}
}
if (found != -1) {
Type nont = RascalTypeFactory.getInstance().nonTerminalType(foundType);
IValue child = TreeAdapter.getArgs(tree).get(found);
return makeResult(nont, child, ctx);
}
}
}
if (tree.getConstructorType().hasField(name)) {
return makeResult(tree.getConstructorType().getFieldType(name), tree.get(name), ctx);
}
throw RuntimeExceptionFactory.noSuchField(name, ctx.getCurrentAST(), ctx.getStackTrace());
}
public IString prompt(final IString prompt) {
final String[] value = new String[1];
PlatformUI.getWorkbench()
.getDisplay()
.syncExec(
new Runnable() {
public void run() {
Shell activeShell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
final Shell shell = new Shell(activeShell, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL);
shell.setText(prompt.getValue());
GridLayout gridLayout = new GridLayout();
shell.setLayout(gridLayout);
Label label = new Label(shell, SWT.WRAP);
label.setText(prompt.getValue());
GridData data = new GridData();
Monitor monitor = activeShell.getMonitor();
int maxWidth = monitor.getBounds().width * 2 / 3;
int width = label.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
data.widthHint = Math.min(width, maxWidth);
data.horizontalAlignment = GridData.FILL;
data.grabExcessHorizontalSpace = true;
label.setLayoutData(data);
final Text valueText = new Text(shell, SWT.BORDER);
Listener enterListener =
new Listener() {
public void handleEvent(Event event) {
value[0] = valueText.getText();
shell.close();
}
};
if (value[0] != null) valueText.setText(value[0]);
data = new GridData();
width = valueText.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;
if (width > maxWidth) data.widthHint = maxWidth;
data.horizontalAlignment = GridData.FILL;
data.grabExcessHorizontalSpace = true;
valueText.setLayoutData(data);
valueText.addListener(SWT.DefaultSelection, enterListener);
Composite composite = new Composite(shell, SWT.NONE);
data = new GridData();
data.horizontalAlignment = GridData.CENTER;
composite.setLayoutData(data);
composite.setLayout(new GridLayout(2, true));
Button button = new Button(composite, SWT.PUSH);
button.setText("OK");
button.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
button.addListener(SWT.Selection, enterListener);
shell.pack();
shell.open();
Display display = activeShell.getDisplay();
while (!shell.isDisposed()) {
if (!display.readAndDispatch()) display.sleep();
}
}
});
if (value[0] != null) {
return vf.string(value[0]);
}
throw RuntimeExceptionFactory.io(vf.string("no input"), null, null);
}
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);
}
}
}
}
