Iterator<Type> iter = conses.iterator();
while (iter.hasNext()) {
try {
@SuppressWarnings("unused")
Type cons = iter.next();
ISourceLocation loc = TreeAdapter.getLocation(tree);
IConstructor ast = makeConstructor(type, constructorName, ctx, values.string(yield));
return ast.asAnnotatable().setAnnotation("location", loc);
}
catch (Backtrack b) {
continue;
}
}
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Cannot find a constructor " + type));
}
if (type.isInteger()) {
return values.integer(yield);
}
if (type.isReal()) {
return values.real(yield);
}
if (type.isBool()) {
if (yield.equals("true")) {
return values.bool(true);
}
if (yield.equals("false")) {
return values.bool(false);
}
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Bool type does not match with " + yield));
}
if (type.isString() || isUntypedNodeType(type)) {
// NB: in "node space" all lexicals become strings
return values.string(yield);
}
throw RuntimeExceptionFactory.illegalArgument(tree, null, null, "Missing lexical constructor");
}
//Set implementation added here by Jurgen at 19/07/12 16:45
if (TreeAdapter.isList(tree)) {
if (type.isList() || splicing || isUntypedNodeType(type)) {
// if in node space, we also make a list;
// NB: this breaks type safety if the top-level tree
// is itself a list.
Type elementType = type;
if (!splicing && !isUntypedNodeType(type)) {
elementType = type.getElementType();
}
IListWriter w = values.listWriter();
for (IValue arg: TreeAdapter.getListASTArgs(tree)) {
w.append(implode(store, elementType, (IConstructor) arg, false, ctx));
}
return w.done();
}
else if (type.isSet()) {
Type elementType = splicing ? type : type.getElementType();
ISetWriter w = values.setWriter();
for (IValue arg: TreeAdapter.getListASTArgs(tree)) {
w.insert(implode(store, elementType, (IConstructor) arg, false, ctx));
}
return w.done();
}
else {
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Cannot match list with " + type));
}
}
//Changes end here
if (TreeAdapter.isOpt(tree) && type.isBool()) {
IList args = TreeAdapter.getArgs(tree);
if (args.isEmpty()) {
return values.bool(false);
}
return values.bool(true);
}
if (TreeAdapter.isOpt(tree)) {
if (!type.isList() && !isUntypedNodeType(type)) {
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Optional should match with a list and not " + type));
}
Type elementType = isUntypedNodeType(type) ? type : type.getElementType();
IListWriter w = values.listWriter();
for (IValue arg: TreeAdapter.getASTArgs(tree)) {
IValue implodedArg = implode(store, elementType, (IConstructor) arg, true, ctx);
if (implodedArg instanceof IList) {
// splicing
for (IValue nextArg: (IList)implodedArg) {
w.append(nextArg);
}
}
else {
w.append(implodedArg);
}
// opts should have one argument (if any at all)
break;
}
return w.done();
}
if (TreeAdapter.isAmb(tree)) {
if (!type.isSet()) {
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Ambiguous node should match with set and not " + type));
}
Type elementType = type.getElementType();
ISetWriter w = values.setWriter();
for (IValue arg: TreeAdapter.getAlternatives(tree)) {
w.insert(implode(store, elementType, (IConstructor) arg, false, ctx));
}
return w.done();
}
if (ProductionAdapter.hasAttribute(TreeAdapter.getProduction(tree), Factory.Attribute_Bracket)) {
return implode(store, type, (IConstructor) TreeAdapter.getASTArgs(tree).get(0), false, ctx);
}
if (TreeAdapter.isAppl(tree)) {
IList args = TreeAdapter.getASTArgs(tree);
int j = 0;
IMapWriter cw = values.mapWriter();
IListWriter aw = values.listWriter();
for (IValue kid : TreeAdapter.getArgs(tree)) {
if (TreeAdapter.isLayout((IConstructor) kid)) {
IList cts = extractComments((IConstructor) kid);
if (!cts.isEmpty()) {
cw.put(values.integer(j), cts);
}
j++;
}
else if (!TreeAdapter.isLiteral((IConstructor) kid) &&
!TreeAdapter.isCILiteral((IConstructor) kid) &&
!TreeAdapter.isEmpty((IConstructor) kid)) {
aw.append(kid);
}
}
args = aw.done();
int length = args.length();
IMap comments = cw.done();
// // this could be optimized.
// i = 0;
// int length = args.length();
// while (i < length) {
// if (TreeAdapter.isEmpty((IConstructor) args.get(i))) {
// length--;
// args = args.delete(i);
// }
// else {
// i++;
// }
// }
java.lang.String constructorName = unescapedConsName(tree);
if (constructorName == null) {
if (length == 1) {
// jump over injection
return implode(store, type, (IConstructor) args.get(0), splicing, ctx);
}
// make a tuple if we're in node space
if (isUntypedNodeType(type)) {
return values.tuple(implodeArgs(store, type, args, ctx));
}
if (!type.isTuple()) {
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Constructor does not match with " + type));
}
if (length != type.getArity()) {
throw new Backtrack(RuntimeExceptionFactory.arityMismatch(type.getArity(), length, null, null));
}
return values.tuple(implodeArgs(store, type, args, ctx));
}
// if in node space, make untyped nodes
if (isUntypedNodeType(type)) {
INode ast = values.node(constructorName, implodeArgs(store, type, args, ctx));
return ast.asAnnotatable().setAnnotation("location", TreeAdapter.getLocation(tree)).asAnnotatable().setAnnotation("comments", comments);
}
// make a typed constructor
if (!type.isAbstractData()) {
throw new Backtrack(RuntimeExceptionFactory.illegalArgument(tree, null, null, "Constructor (" + constructorName + ") should match with abstract data type and not with " + type));
}
Set<Type> conses = findConstructors(type, constructorName, length, store);
Iterator<Type> iter = conses.iterator();
while (iter.hasNext()) {
try {
Type cons = iter.next();
ISourceLocation loc = TreeAdapter.getLocation(tree);
IValue[] implodedArgs = implodeArgs(store, cons, args, ctx);
IConstructor ast = makeConstructor(type, constructorName, ctx, implodedArgs);
return ast.asAnnotatable().setAnnotation("location", loc).asAnnotatable().setAnnotation("comments", comments);
}
catch (Backtrack b) {