@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 void list(
final String project,
final String module,
IConstructor parseTree,
final IProgressMonitor monitor) {
table.removeAll();
try {
parseTree.accept(
new IdentityTreeVisitor<Exception>() {
int ambTreesSeen = 0;
@Override
public ITree visitTreeAppl(ITree arg) throws Exception {
if (monitor.isCanceled()) {
throw new Exception("interrupted");
}
monitor.worked(1);
for (IValue child : TreeAdapter.getArgs(arg)) {
child.accept(this);
}
return arg;
}
@Override
public ITree visitTreeAmb(ITree arg) throws Exception {
ambTreesSeen++;
if (ambTreesSeen > 100) {
throw new RuntimeException(
"Lets stop collecting, the user get's the point, it is VERY ambigious");
}
IConstructor sym = null;
String sentence = TreeAdapter.yield(arg);
for (IValue child : TreeAdapter.getAlternatives(arg)) {
sym = TreeAdapter.getType((ITree) child);
child.accept(this);
}
addItem(sym, sentence, module, project, arg);
return arg;
}
});
} catch (Exception e) {
// do nothing
}
}
private boolean isDesugarCandidate(IConstructor o) {
if (o instanceof AnnotatedConstructorFacade) {
AnnotatedConstructorFacade acf = (AnnotatedConstructorFacade) o;
if (acf.getType() instanceof NonTerminalType) {
NonTerminalType ntt = (NonTerminalType) acf.getType();
String name = SymbolAdapter.toString(ntt.getSymbol(), false);
if (eval.getCurrentEnvt().lookupAbstractDataType(name) != null
|| eval.getCurrentEnvt().lookupConcreteSyntaxType(name) != null) {
return true;
}
}
return false;
}
// TODO Hack.
return (o.getClass()
.toString()
.equals("class org.eclipse.imp.pdb.facts.impl.fast.Constructor"));
// System.out.println("Scheiße!");
// System.out.println(o.getClass());
// return false;
}
public Object loadPT(IConstructor[] fileRef, String sourcePath, String sourceName) {
IConstructor file = fileRef[0];
ISourceLocation loc = TreeAdapter.getLocation(file);
int lineNumber = loc.getBeginLine();
Object ret = null;
Var.pushThreadBindings(
RT.map(
LOADER,
RT.makeClassLoader(),
SOURCE_PATH,
sourcePath,
SOURCE,
sourceName,
METHOD,
null,
LOCAL_ENV,
null,
LOOP_LOCALS,
null,
NEXT_LOCAL_NUM,
0,
RT.CURRENT_NS,
RT.CURRENT_NS.deref(),
LINE_BEFORE,
lineNumber,
LINE_AFTER,
lineNumber,
RT.UNCHECKED_MATH,
RT.UNCHECKED_MATH.deref(),
RT.WARN_ON_REFLECTION,
RT.WARN_ON_REFLECTION.deref(),
RT.DATA_READERS,
RT.DATA_READERS.deref()));
UPTRLispReader reader = new UPTRLispReader(vf, errors);
try {
if (TreeAdapter.isAmb(file)) {
System.err.println("Amb");
}
// File is start[File], so
IConstructor file2 = (IConstructor) TreeAdapter.getArgs(file).get(1);
IList args = TreeAdapter.getArgs(file2);
// Probably only this is the list of forms; don't forget to fix
// below.
IList forms = TreeAdapter.getArgs((IConstructor) args.get(0));
IListWriter newArgs = vf.listWriter();
for (int i = 0; i < forms.length(); i++) {
IConstructor form = (IConstructor) forms.get(i);
// only forms, no literals at this level.
UPTRLispReader.Pair p = reader.read(form);
newArgs.append(p.tree);
LINE_AFTER.set(TreeAdapter.getLocation(form).getEndLine());
ret = eval(p.obj, false);
LINE_BEFORE.set(TreeAdapter.getLocation(form).getBeginLine());
if (i < forms.length() - 2) {
i++;
newArgs.append(forms.get(i)); // layout
}
}
// Fix tree
file2 = file2.set("args", newArgs.done());
file =
file.set(
"args",
vf.list(TreeAdapter.getArgs(file).get(0), file2, TreeAdapter.getArgs(file).get(2)));
} catch (UPTRLispReader.ReaderException e) {
throw new CompilerException(sourcePath, e.line, e.getCause());
} finally {
Var.popThreadBindings();
}
fileRef[0] = file;
return ret;
}
public boolean isFatal() {
return error.getConstructorType() == Factory.Error_Fatal;
}
public boolean isInfo() {
return error.getConstructorType() == Factory.Error_Info;
}
public boolean isWarning() {
return error.getConstructorType() == Factory.Error_Warning;
}
public boolean isError() {
return error.getConstructorType() == Factory.Error_Error;
}
public String getDescription() {
return ((IString) error.get("description")).getValue();
}
public IList getSubjects() {
return (IList) error.get("subjects");
}
@Override
protected Result<IBool> equalToConcreteSyntax(ConcreteSyntaxResult that) {
IConstructor left = this.getValue();
IConstructor right = that.getValue();
if (TreeAdapter.isLayout(left) && TreeAdapter.isLayout(right)) {
return bool(true, ctx);
}
if (TreeAdapter.isAppl(left) && TreeAdapter.isAppl(right)) {
IConstructor p1 = TreeAdapter.getProduction(left);
IConstructor p2 = TreeAdapter.getProduction(right);
if (!p1.isEqual(p2)) {
return bool(false, ctx);
}
IList l1 = TreeAdapter.getArgs(left);
IList l2 = TreeAdapter.getArgs(right);
if (l1.length() != l2.length()) {
return bool(false, ctx);
}
for (int i = 0; i < l1.length(); i++) {
IValue kid1 = l1.get(i);
IValue kid2 = l2.get(i);
// Recurse here on kids to reuse layout handling etc.
Result<IBool> result =
makeResult(kid1.getType(), kid1, ctx).equals(makeResult(kid2.getType(), kid2, ctx));
if (!result.getValue().getValue()) {
return bool(false, ctx);
}
if (TreeAdapter.isContextFree(left)) {
i++; // skip layout
}
}
return bool(true, ctx);
}
if (TreeAdapter.isChar(left) && TreeAdapter.isChar(right)) {
return bool((TreeAdapter.getCharacter(left) == TreeAdapter.getCharacter(right)), ctx);
}
if (TreeAdapter.isAmb(left) && TreeAdapter.isAmb(right)) {
ISet alts1 = TreeAdapter.getAlternatives(left);
ISet alts2 = TreeAdapter.getAlternatives(right);
if (alts1.size() != alts2.size()) {
return bool(false, ctx);
}
// TODO: this is very inefficient
again:
for (IValue alt1 : alts1) {
for (IValue alt2 : alts2) {
Result<IBool> result =
makeResult(alt1.getType(), alt1, ctx).equals(makeResult(alt2.getType(), alt2, ctx));
if (result.getValue().getValue()) {
// As soon an alt1 is equal to an alt2
// continue the outer loop.
continue again;
}
}
// If an alt1 is not equal to any of the the alt2's return false;
return bool(false, ctx);
}
return bool(true, ctx);
}
return bool(false, ctx);
}
private IValue desugarChildren(IConstructor o) throws E {
for (int i = 0; i < o.arity(); i++) {
o = o.set(i, o.get(i).accept(this));
}
return fVisitor.visitConstructor(o);
}