# HG changeset patch
# User Christian Wimmer <christian.wimmer@oracle.com>
# Date 1359999411 28800
# Node ID fa2ecdace0f746b352621d7bb2c636356c86ef6b
# Parent  47467b2c3fc5c7d40a3fb8b650b4143999767b3c# Parent  d163365572152128f2e96ffbe66658880cf3b62b
Merge

diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/FrameTest.java
--- a/graal/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/FrameTest.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/FrameTest.java	Mon Feb 04 09:36:51 2013 -0800
@@ -41,12 +41,12 @@
  * </p>
  * 
  * <p>
- * There are five primitive types for slots available: {@link java.lang.Boolean}, @{link
- * java.lang.Integer}, {@link java.lang.Long}, {@link java.lang.Float}, and {@link java.lang.Double}
- * . It is encouraged to use those types whenever possible. Dynamically typed languages can
- * speculate on the type of a value fitting into a primitive (see
+ * There are five primitive types for slots available: {@link java.lang.Boolean},
+ * {@link java.lang.Integer}, {@link java.lang.Long}, {@link java.lang.Float}, and
+ * {@link java.lang.Double} . It is encouraged to use those types whenever possible. Dynamically
+ * typed languages can speculate on the type of a value fitting into a primitive (see
  * {@link FrameSlotTypeSpecializationTest}). When a frame slot is of one of those particular
- * primitive types, its value may only be accessed with the repectively typed getter method (
+ * primitive types, its value may only be accessed with the respectively typed getter method (
  * {@link Frame#getBoolean}, {@link Frame#getInt}, {@link Frame#getLong}, {@link Frame#getFloat}, or
  * {@link Frame#getDouble}) or setter method ({@link Frame#setBoolean}, {@link Frame#setInt},
  * {@link Frame#setLong}, {@link Frame#setFloat}, or {@link Frame#setDouble}) in the {@link Frame}
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/Log.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/Log.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/Log.java	Mon Feb 04 09:36:51 2013 -0800
@@ -33,6 +33,8 @@
  */
 public class Log {
 
+    public static final boolean DEBUG = false;
+
     private final ProcessingEnvironment processingEnv;
 
     public Log(ProcessingEnvironment env) {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/ast/CodeAnnotationValue.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/ast/CodeAnnotationValue.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/ast/CodeAnnotationValue.java	Mon Feb 04 09:36:51 2013 -0800
@@ -31,22 +31,16 @@
 
     private final Object value;
 
-    // @formatter:off
     public CodeAnnotationValue(Object value) {
         Objects.requireNonNull(value);
-        if ((value instanceof AnnotationMirror) || (value instanceof List< ? >)
-                        || (value instanceof Boolean) || (value instanceof Byte)
-                        || (value instanceof Character) || (value instanceof Double)
-                        || (value instanceof VariableElement) || (value instanceof Float)
-                        || (value instanceof Integer) || (value instanceof Long)
-                        || (value instanceof Short) || (value instanceof String)
-                        || (value instanceof TypeMirror)) {
+        if ((value instanceof AnnotationMirror) || (value instanceof List<?>) || (value instanceof Boolean) || (value instanceof Byte) || (value instanceof Character) || (value instanceof Double) ||
+                        (value instanceof VariableElement) || (value instanceof Float) || (value instanceof Integer) || (value instanceof Long) || (value instanceof Short) ||
+                        (value instanceof String) || (value instanceof TypeMirror)) {
             this.value = value;
         } else {
             throw new IllegalArgumentException("Invalid annotation value type " + value.getClass().getName());
         }
     }
-    // @formatter:on
 
     @Override
     public Object getValue() {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/codewriter/AbstractCodeWriter.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/codewriter/AbstractCodeWriter.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/codewriter/AbstractCodeWriter.java	Mon Feb 04 09:36:51 2013 -0800
@@ -434,16 +434,6 @@
         }
     }
 
-    // @Override
-    // public void visitParameter(CodeVariableElement e) {
-    // for (CodeAnnotationMirror annotation : e.getAnnotationMirrors()) {
-    // annotation.accept(this);
-    // }
-    // write(typeSimpleName(e.getType()));
-    // write(" ");
-    // write(e.getSimpleName());
-    // }
-
     @Override
     public Void visitExecutable(CodeExecutableElement e, Void p) {
         for (AnnotationMirror annotation : e.getAnnotationMirrors()) {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java	Mon Feb 04 09:36:51 2013 -0800
@@ -653,13 +653,13 @@
             if (specialization.getExceptions().length > 0) {
                 for (SpecializationThrowsData exception : specialization.getExceptions()) {
                     builder.end().startCatchBlock(exception.getJavaClass(), "ex");
-                    buildThrowSpecialize(builder, exception.getTransitionTo(), null);
+                    buildThrowSpecialize(builder, specialization, exception.getTransitionTo(), null);
                 }
                 builder.end();
             }
             if (specialization.hasDynamicGuards()) {
                 builder.end().startElseBlock();
-                buildThrowSpecialize(builder, specialization.findNextSpecialization(), null);
+                buildThrowSpecialize(builder, specialization, specialization.findNextSpecialization(), null);
                 builder.end();
             }
         }
@@ -737,7 +737,7 @@
                         execute = true;
                     }
                 }
-                buildThrowSpecialize(builder, specialization.findNextSpecialization(), param.getSpecification());
+                buildThrowSpecialize(builder, specialization, specialization.findNextSpecialization(), param.getSpecification());
                 builder.end(); // catch block
             }
 
@@ -785,7 +785,7 @@
             }
         }
 
-        private void buildThrowSpecialize(CodeTreeBuilder builder, SpecializationData nextSpecialization, ParameterSpec exceptionSpec) {
+        private void buildThrowSpecialize(CodeTreeBuilder builder, SpecializationData currentSpecialization, SpecializationData nextSpecialization, ParameterSpec exceptionSpec) {
             boolean canThrowUnexpected = Utils.canThrowType(builder.findMethod().getThrownTypes(), getContext().getTruffleTypes().getUnexpectedValueException());
 
             CodeTreeBuilder specializeCall = CodeTreeBuilder.createBuilder();
@@ -795,10 +795,12 @@
             specializeCall.end().end();
 
             if (canThrowUnexpected) {
-                builder.startThrow();
-                builder.startNew(getContext().getTruffleTypes().getUnexpectedValueException());
+                builder.startReturn();
+                TypeData expectedType = currentSpecialization.getReturnType().getActualTypeData(currentSpecialization.getNode().getTypeSystem());
+                startCallTypeSystemMethod(context, builder, currentSpecialization.getNode(), TypeSystemCodeGenerator.expectTypeMethodName(expectedType));
                 builder.tree(specializeCall.getRoot());
                 builder.end().end();
+                builder.end(); // return
             } else {
                 builder.startReturn();
                 builder.tree(specializeCall.getRoot());
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeData.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeData.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeData.java	Mon Feb 04 09:36:51 2013 -0800
@@ -133,7 +133,8 @@
         } else {
             ExecutableTypeData execType = null;
             for (ExecutableTypeData type : types) {
-                if (!type.getReturnType().getActualTypeData(getTypeSystem()).isVoid()) {
+                TypeData returnType = type.getReturnType().getActualTypeData(getTypeSystem());
+                if (!returnType.isVoid()) {
                     if (execType != null) {
                         // multiple generic types not allowed
                         return null;
@@ -280,25 +281,12 @@
         return specializations;
     }
 
-    // @formatter:off
     public String dump() {
         StringBuilder b = new StringBuilder();
-        b.append(String.format("[name = %s\n" +
-                        "  typeSystem = %s\n" +
-                        "  fields = %s\n" +
-                        "  types = %s\n" +
-                        "  specializations = %s\n" +
-                        "  guards = %s\n" +
-                        "]", Utils.getQualifiedName(getTemplateType()),
-                            getTypeSystem(),
-                            dumpList(fields),
-                            dumpList(getExecutableTypes()),
-                            dumpList(getSpecializations()),
-                            dumpList(guards)
-                        ));
+        b.append(String.format("[name = %s\n" + "  typeSystem = %s\n" + "  fields = %s\n" + "  types = %s\n" + "  specializations = %s\n" + "  guards = %s\n" + "]",
+                        Utils.getQualifiedName(getTemplateType()), getTypeSystem(), dumpList(fields), dumpList(getExecutableTypes()), dumpList(getSpecializations()), dumpList(guards)));
         return b.toString();
     }
-    // @formatter:on
 
     private static String dumpList(Object[] array) {
         if (array == null) {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeParser.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeParser.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeParser.java	Mon Feb 04 09:36:51 2013 -0800
@@ -44,8 +44,6 @@
     public static final List<Class<? extends Annotation>> ANNOTATIONS = Arrays.asList(Generic.class, GuardCheck.class, TypeSystemReference.class, ShortCircuit.class, Specialization.class,
                     SpecializationGuard.class, SpecializationListener.class, SpecializationThrows.class);
 
-    private static final boolean DEBUG = false;
-
     private Map<String, NodeData> parsedNodes;
     private TypeElement originalType;
 
@@ -62,7 +60,7 @@
 
             return parseInnerClassHierarchy((TypeElement) element);
         } finally {
-            if (DEBUG) {
+            if (Log.DEBUG) {
                 NodeData parsed = parsedNodes.get(Utils.getQualifiedName(originalType));
                 if (parsed != null) {
                     String dump = parsed.dump();
@@ -149,7 +147,7 @@
         nodeData.setExecutableTypes(executableTypes.toArray(new ExecutableTypeData[executableTypes.size()]));
 
         parsedNodes.put(Utils.getQualifiedName(type), nodeData); // node fields will resolve node
-                                                                 // types, to avoid endless loops
+// types, to avoid endless loops
 
         NodeFieldData[] fields = parseFields(nodeData, elements, typeHierarchy);
         if (fields == null) {
@@ -319,6 +317,19 @@
                 filteredExecutableTypes.add(t1);
             }
         }
+
+        Collections.sort(filteredExecutableTypes, new Comparator<ExecutableTypeData>() {
+
+            @Override
+            public int compare(ExecutableTypeData o1, ExecutableTypeData o2) {
+                int index1 = o1.getTypeSystem().findType(o1.getType());
+                int index2 = o2.getTypeSystem().findType(o2.getType());
+                if (index1 == -1 || index2 == -1) {
+                    return 0;
+                }
+                return index1 - index2;
+            }
+        });
         return filteredExecutableTypes;
     }
 
@@ -425,7 +436,8 @@
                 context.getLog().error(errorElement, "Node type '%s' is invalid.", Utils.getQualifiedName(nodeType));
                 return null;
             } else if (fieldNodeData.findGenericExecutableType(context) == null) {
-                context.getLog().error(errorElement, "No executable generic type found for node '%s'.", Utils.getQualifiedName(nodeType));
+                // TODO better error handling for (no or multiple?)
+                context.getLog().error(errorElement, "No or multiple executable generic types found for node '%s'.", Utils.getQualifiedName(nodeType));
                 return null;
             }
         }
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/SpecializationMethodParser.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/SpecializationMethodParser.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/SpecializationMethodParser.java	Mon Feb 04 09:36:51 2013 -0800
@@ -144,7 +144,8 @@
                 ParameterSpec spec = param.getSpecification();
                 expectedParameterSpecs.add(new ParameterSpec(spec.getName(), param.getActualType(), false));
             }
-            String expectedSignature = TemplateMethodParser.createExpectedSignature(specializationGuard.getGuardMethod(), returnTypeSpec, expectedParameterSpecs);
+            List<TypeDef> typeDefs = createTypeDefinitions(returnTypeSpec, expectedParameterSpecs);
+            String expectedSignature = TemplateMethodParser.createExpectedSignature(specializationGuard.getGuardMethod(), returnTypeSpec, expectedParameterSpecs, typeDefs);
             AnnotationValue value = Utils.getAnnotationValue(mirror, "methodName");
             getContext().getLog().error(specialization.getMethod(), mirror, value, "No guard with signature '%s' found in type system.", expectedSignature);
             return null;
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/template/TemplateMethodParser.java	Mon Feb 04 09:36:51 2013 -0800
@@ -120,6 +120,8 @@
             return null;
         }
 
+        List<TypeDef> typeDefs = createTypeDefinitions(methodSpecification.getReturnType(), methodSpecification.getParameters());
+
         ParameterSpec returnTypeSpec = methodSpecification.getReturnType();
         List<ParameterSpec> parameterSpecs = new ArrayList<>();
         parameterSpecs.addAll(methodSpecification.getParameters());
@@ -127,11 +129,11 @@
         ActualParameter returnTypeMirror = resolveTypeMirror(returnTypeSpec, method.getReturnType(), template);
         if (returnTypeMirror == null) {
             if (isEmitErrors()) {
-                String expectedReturnType = createTypeSignature(returnTypeSpec, true);
+                String expectedReturnType = createTypeSignature(returnTypeSpec, typeDefs, true);
                 String actualReturnType = Utils.getSimpleName(method.getReturnType());
 
                 String message = String.format("The provided return type \"%s\" does not match expected return type \"%s\".\nExpected signature: \n %s", actualReturnType, expectedReturnType,
-                                createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+                                createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 
                 context.getLog().error(method, annotation, message);
             }
@@ -160,10 +162,10 @@
                 } else if (!specification.isOptional()) {
                     if (isEmitErrors()) {
                         // non option type specification found -> argument missing
-                        String expectedType = createTypeSignature(specification, false);
+                        String expectedType = createTypeSignature(specification, typeDefs, false);
 
                         String message = String.format("Missing argument \"%s\".\nExpected signature: \n %s", expectedType,
-                                        createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+                                        createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 
                         context.getLog().error(method, message);
                     }
@@ -184,11 +186,11 @@
                 }
 
                 if (isEmitErrors()) {
-                    String expectedReturnType = createTypeSignature(specification, false);
+                    String expectedReturnType = createTypeSignature(specification, typeDefs, false);
                     String actualReturnType = Utils.getSimpleName(parameter.asType()) + " " + parameter.getSimpleName();
 
                     String message = String.format("The provided argument type \"%s\" does not match expected type \"%s\".\nExpected signature: \n %s", actualReturnType, expectedReturnType,
-                                    createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+                                    createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 
                     context.getLog().error(parameter, message);
                 }
@@ -208,7 +210,7 @@
             if (isEmitErrors()) {
                 String actualReturnType = Utils.getSimpleName(parameter.asType()) + " " + parameter.getSimpleName();
                 String message = String.format("No argument expected but found \"%s\".\nExpected signature: \n %s", actualReturnType,
-                                createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs));
+                                createExpectedSignature(method.getSimpleName().toString(), returnTypeSpec, parameterSpecs, typeDefs));
 
                 context.getLog().error(parameter, message);
             }
@@ -231,11 +233,67 @@
         return new ActualParameter(specification, resolvedType);
     }
 
-    public static String createExpectedSignature(String methodName, ParameterSpec returnType, List<? extends ParameterSpec> parameters) {
+    protected static List<TypeDef> createTypeDefinitions(ParameterSpec returnType, List<? extends ParameterSpec> parameters) {
+        List<TypeDef> typeDefs = new ArrayList<>();
+
+        TypeMirror[] types = returnType.getAllowedTypes();
+        List<ParameterSpec> allParams = new ArrayList<>();
+        allParams.add(returnType);
+        allParams.addAll(parameters);
+
+        int defIndex = 0;
+        for (ParameterSpec spec : allParams) {
+            TypeMirror[] allowedTypes = spec.getAllowedTypes();
+            if (types != null && allowedTypes.length > 1) {
+                TypeDef foundDef = null;
+                for (TypeDef def : typeDefs) {
+                    if (Arrays.equals(spec.getAllowedTypes(), def.getTypes())) {
+                        foundDef = def;
+                        break;
+                    }
+                }
+                if (foundDef == null) {
+                    foundDef = new TypeDef(types, "Types" + defIndex);
+                    typeDefs.add(foundDef);
+                    defIndex++;
+                }
+
+                foundDef.getParameters().add(spec);
+            }
+        }
+
+        return typeDefs;
+    }
+
+    protected static class TypeDef {
+
+        private final TypeMirror[] types;
+        private final String name;
+        private final List<ParameterSpec> parameters = new ArrayList<>();
+
+        public TypeDef(TypeMirror[] types, String name) {
+            this.types = types;
+            this.name = name;
+        }
+
+        public List<ParameterSpec> getParameters() {
+            return parameters;
+        }
+
+        public TypeMirror[] getTypes() {
+            return types;
+        }
+
+        public String getName() {
+            return name;
+        }
+    }
+
+    public static String createExpectedSignature(String methodName, ParameterSpec returnType, List<? extends ParameterSpec> parameters, List<TypeDef> typeDefs) {
         StringBuilder b = new StringBuilder();
 
         b.append("    ");
-        b.append(createTypeSignature(returnType, true));
+        b.append(createTypeSignature(returnType, typeDefs, true));
 
         b.append(" ");
         b.append(methodName);
@@ -250,7 +308,7 @@
                 b.append("{");
             }
 
-            b.append(createTypeSignature(specification, false));
+            b.append(createTypeSignature(specification, typeDefs, false));
 
             if (specification.isOptional()) {
                 b.append("]");
@@ -268,34 +326,40 @@
 
         b.append(")");
 
-        TypeMirror[] types = null;
+        if (!typeDefs.isEmpty()) {
+            b.append("\n\n");
 
-        // TODO allowed types may differ so different <Any> must be generated.
-        if (returnType.getAllowedTypes().length > 1) {
-            types = returnType.getAllowedTypes();
-        }
-        for (ParameterSpec param : parameters) {
-            if (param.getAllowedTypes().length > 1) {
-                types = param.getAllowedTypes();
+            String lineSep = "";
+            for (TypeDef def : typeDefs) {
+                b.append(lineSep);
+                b.append("    <").append(def.getName()).append(">");
+                b.append(" = {");
+                String separator = "";
+                for (TypeMirror type : def.getTypes()) {
+                    b.append(separator).append(Utils.getSimpleName(type));
+                    separator = ", ";
+                }
+                b.append("}");
+                lineSep = "\n";
+
             }
         }
-        if (types != null) {
-            b.append("\n\n    ");
-            b.append("<Any> = {");
-            String separator = "";
-            for (TypeMirror type : types) {
-                b.append(separator).append(Utils.getSimpleName(type));
-                separator = ", ";
-            }
-            b.append("}");
-        }
         return b.toString();
     }
 
-    private static String createTypeSignature(ParameterSpec spec, boolean typeOnly) {
+    private static String createTypeSignature(ParameterSpec spec, List<TypeDef> typeDefs, boolean typeOnly) {
         StringBuilder builder = new StringBuilder();
         if (spec.getAllowedTypes().length > 1) {
-            builder.append("<Any>");
+            TypeDef foundTypeDef = null;
+            for (TypeDef typeDef : typeDefs) {
+                if (typeDef.getParameters().contains(spec)) {
+                    foundTypeDef = typeDef;
+                    break;
+                }
+            }
+            if (foundTypeDef != null) {
+                builder.append("<" + foundTypeDef.getName() + ">");
+            }
         } else if (spec.getAllowedTypes().length == 1) {
             builder.append(Utils.getSimpleName(spec.getAllowedTypes()[0]));
         } else {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemData.java
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemData.java	Mon Feb 04 09:31:44 2013 -0800
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemData.java	Mon Feb 04 09:36:51 2013 -0800
@@ -114,6 +114,10 @@
         return types[index];
     }
 
+    public int findType(TypeData typeData) {
+        return findType(typeData.getPrimitiveType());
+    }
+
     public int findType(TypeMirror type) {
         for (int i = 0; i < types.length; i++) {
             if (Utils.typeEquals(types[i].getPrimitiveType(), type)) {
diff -r 47467b2c3fc5 -r fa2ecdace0f7 mxtool/mx.py
--- a/mxtool/mx.py	Mon Feb 04 09:31:44 2013 -0800
+++ b/mxtool/mx.py	Mon Feb 04 09:36:51 2013 -0800
@@ -2096,21 +2096,23 @@
                 out.close('buildCommand')
 
         if (_needsEclipseJarBuild(p)):
-            out.open('buildCommand')
-            out.element('name', data='org.eclipse.ui.externaltools.ExternalToolBuilder')
-            out.element('triggers', data='auto,full,incremental,')
-            out.open('arguments')
-            out.open('dictionary')
-            out.element('key', data = 'LaunchConfigHandle')
-            out.element('value', data = _genEclipseJarBuild(p))
-            out.close('dictionary')
-            out.open('dictionary')
-            out.element('key', data = 'incclean')
-            out.element('value', data = 'true')
-            out.close('dictionary')
-            out.close('arguments')
-            out.close('buildCommand')       
-                
+            targetValues = _genEclipseJarBuild(p);
+            for value in targetValues:
+                out.open('buildCommand')
+                out.element('name', data='org.eclipse.ui.externaltools.ExternalToolBuilder')
+                out.element('triggers', data='auto,full,incremental,')
+                out.open('arguments')
+                out.open('dictionary')
+                out.element('key', data = 'LaunchConfigHandle')
+                out.element('value', data = value)
+                out.close('dictionary')
+                out.open('dictionary')
+                out.element('key', data = 'incclean')
+                out.element('value', data = 'true')
+                out.close('dictionary')
+                out.close('arguments')
+                out.close('buildCommand')       
+                    
         out.close('buildSpec')
         out.open('natures')
         out.element('nature', data='org.eclipse.jdt.core.javanature')
@@ -2184,12 +2186,20 @@
     return False
 
 def _genEclipseJarBuild(p):
+    builders = []
+    builders.append(_genEclipseLaunch(p, 'Jar.launch', ''.join(['jar ', p.name]), refresh = False, async = False))
+    builders.append(_genEclipseLaunch(p, 'Refresh.launch', '', refresh = True, async = True))
+    return builders
+
+def _genEclipseLaunch(p, name, mxCommand, refresh=True, async=False):
     launchOut = XMLDoc();
     launchOut.open('launchConfiguration', {'type' : 'org.eclipse.ui.externaltools.ProgramBuilderLaunchConfigurationType'})
-    launchOut.element('stringAttribute',  {'key' : 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE',            'value': '${project}'})
+    if refresh:
+        launchOut.element('stringAttribute',  {'key' : 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE',            'value': '${project}'})
     launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.core.capture_output',                'value': 'false'})
     launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_CONSOLE_OUTPUT_ON',          'value': 'false'})
-    launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND',       'value': 'true'})
+    if async:
+        launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND',       'value': 'true'})
     
     baseDir = dirname(dirname(os.path.abspath(__file__)))
     
@@ -2198,7 +2208,7 @@
         cmd = 'mx.cmd'
     launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_LOCATION',           'value': join(baseDir, cmd) })
     launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS',    'value': 'auto,full,incremental'})
-    launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS',     'value': ''.join(['jar', ' ', p.name])})
+    launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS',     'value': mxCommand})
     launchOut.element('booleanAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED','value': 'true'})
     launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY',  'value': baseDir})
     
@@ -2209,11 +2219,9 @@
     
     if not exists(externalToolDir):
         os.makedirs(externalToolDir)
-    update_file(join(externalToolDir, 'Jar.launch'), launchOut.xml(indent='\t', newl='\n'))
+    update_file(join(externalToolDir, name), launchOut.xml(indent='\t', newl='\n'))
     
-    return "<project>/.externalToolBuilders/Jar.launch"
-
-
+    return ''.join(["<project>/.externalToolBuilders/", name])
 
 
 def netbeansinit(args, suite=None):