diff -r 000000000000 -r 263482b074e9 dew/src/main/java/org/apidesign/bck2brwsr/dew/ClassLoaderFileManager.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dew/src/main/java/org/apidesign/bck2brwsr/dew/ClassLoaderFileManager.java	Wed Oct 02 21:00:24 2013 +0200
@@ -0,0 +1,331 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.apidesign.bck2brwsr.dew;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardLocation;
+
+/**
+ *
+ * @author Tomas Zezula
+ */
+public class ClassLoaderFileManager implements JavaFileManager {
+
+    private static final Location[] READ_LOCATIONS = {
+        StandardLocation.PLATFORM_CLASS_PATH,
+        StandardLocation.CLASS_PATH,
+        StandardLocation.SOURCE_PATH
+    };
+
+    private static final Location[] WRITE_LOCATIONS = {
+        StandardLocation.CLASS_OUTPUT,
+        StandardLocation.SOURCE_OUTPUT
+    };
+
+    private static final Location[] CLASS_LOADER_LOCATIONS = {
+        StandardLocation.ANNOTATION_PROCESSOR_PATH
+    };
+
+    private Map<Location, Map<String,List<MemoryFileObject>>> generated;
+
+
+    ClassLoaderFileManager() {
+        generated = new HashMap<>();
+        for (Location l : WRITE_LOCATIONS) {
+            generated.put(l, new HashMap<String, List<MemoryFileObject>>());
+        }
+    }
+
+
+    @Override
+    public ClassLoader getClassLoader(Location location) {
+        if (canClassLoad(location)) {
+            return getClass().getClassLoader();
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
+        if (canRead(location)) {
+            final List<JavaFileObject> res = new ArrayList<JavaFileObject>();
+            for (String resource : getResources(convertFQNToResource(packageName))) {
+                final JavaFileObject jfo = new ClassLoaderJavaFileObject(resource);
+                if (kinds.contains(jfo.getKind())) {
+                    res.add(jfo);
+                }
+            }
+            return res;
+        } else if (canWrite(location)) {
+            Map<String,List<MemoryFileObject>> folders = generated.get(location);
+            List<MemoryFileObject> files = folders.get(convertFQNToResource(packageName));
+            if (files != null) {
+                final List<JavaFileObject> res = new ArrayList<JavaFileObject>();
+                for (JavaFileObject file : files) {
+                    if (kinds.contains(file.getKind()) && file.getLastModified() >= 0) {
+                        res.add(file);
+                    }
+                }
+                return res;
+            }
+        }
+        return Collections.<JavaFileObject>emptyList();
+    }
+
+    @Override
+    public String inferBinaryName(Location location, JavaFileObject file) {
+        return ((InferableJavaFileObject)file).infer();
+    }
+
+    @Override
+    public boolean isSameFile(FileObject a, FileObject b) {
+        return a.toUri().equals(b.toUri());
+    }
+
+    @Override
+    public boolean handleOption(String current, Iterator<String> remaining) {
+        return false;
+    }
+
+    @Override
+    public boolean hasLocation(Location location) {
+        for (Location l : StandardLocation.values()) {
+            if (l.equals(location)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
+        if (canRead(location)) {
+            return new ClassLoaderJavaFileObject(convertFQNToResource(className) + kind.extension);
+        } else {
+            throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N
+        }
+    }
+
+    @Override
+    public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
+        if (canWrite(location)) {
+            final String resource = convertFQNToResource(className) + kind.extension;
+            final MemoryFileObject res = new MemoryFileObject(resource, null);
+            register(location, resource, res);
+            return res;
+        } else {
+            throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N
+        }
+    }
+
+    @Override
+    public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
+        if (canRead(location)) {
+            return new ClassLoaderJavaFileObject(convertFQNToResource(packageName) + '/' + relativeName); //NOI18N
+        } else {
+            throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N
+        }
+    }
+
+    @Override
+    public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
+        if (canWrite(location)) {
+            final String resource = convertFQNToResource(packageName) + '/' + relativeName; //NOI18N
+            final MemoryFileObject res = new MemoryFileObject(resource, null);
+            register(location, resource, res);
+            return res;
+        } else {
+            throw new UnsupportedOperationException("Unsupported location for reading: " + location);   //NOI18N
+        }
+    }
+
+    @Override
+    public void flush() throws IOException {
+    }
+
+    @Override
+    public void close() throws IOException {        
+    }
+
+    @Override
+    public int isSupportedOption(String option) {
+        return -1;
+    }
+
+//    private List<String> getResources(String folder) throws IOException {
+//        final List<String> result = new ArrayList<String>();
+//        final BufferedReader in = new BufferedReader(new InputStreamReader(
+//                this.getClass().getClassLoader().getResourceAsStream(String.format("%s/pkg-list", folder.substring(0))),    //NOI18N
+//                "UTF-8"));  //NOI18N
+//        try {
+//            String line;
+//            while ((line = in.readLine()) != null) {
+//                result.add(line);
+//            }
+//        } finally {
+//            in.close();
+//        }
+//        return result;
+//    }
+
+    //MOCK IMPL
+    private List<String> getResources(String folder) throws IOException {
+        if (classPathContent == null) {
+            classPathContent = new HashMap<>();
+//            final String boot = System.getProperty("sun.boot.class.path");  //NOI18N
+            final String cp = System.getProperty("java.class.path");
+            for (String entry : cp.split(File.pathSeparator)) {
+                File f = new File (entry);
+                if (f.canRead()) {
+                    if (f.isFile()) {
+                        ZipFile zf = new ZipFile(f);
+                        try {
+                            Enumeration<? extends ZipEntry> entries = zf.entries();
+                            while (entries.hasMoreElements()) {
+                                ZipEntry e = entries.nextElement();
+                                if (e.isDirectory()) {
+                                    continue;
+                                }
+                                final String name = String.format("/%s",e.getName());
+                                final String owner = getOwner(name);
+                                List<String> content = classPathContent.get(owner);
+                                if (content == null) {
+                                    content = new ArrayList<>();
+                                    classPathContent.put(owner, content);
+                                }
+                                content.add(name);
+                            }
+                        } finally {
+                            zf.close();
+                        }
+                    } else if (f.isDirectory()) {
+                        addFiles(f,"/", classPathContent);
+                    }
+                }
+            }                                    
+        }
+        List<String> content = classPathContent.get(folder);
+        return content == null ? Collections.<String>emptyList() : content;
+    }
+
+    private void addFiles(File folder, String path, Map<String,List<String>> into) {
+        for (File f : folder.listFiles()) {
+            String fname = path + (path.length() == 1 ? "" : "/") +  f.getName();
+            if (f.isDirectory()) {
+                addFiles(f, fname, into);
+            } else {
+                List<String> content = into.get(path);
+                if (content == null) {
+                    content = new ArrayList<>();
+                    classPathContent.put(path, content);
+                }
+                content.add(fname);
+            }
+        }
+    }
+    
+    private Map<String,List<String>> classPathContent;
+
+    private void register(Location loc, String resource, MemoryFileObject jfo) {
+        Map<String,List<MemoryFileObject>> folders = generated.get(loc);
+        final String folder = getOwner(resource);
+        List<MemoryFileObject> content = folders.get(folder);
+        if (content == null) {
+            content = new ArrayList<>();
+            folders.put(folder, content);
+        }
+        content.add(jfo);
+    }
+
+    private static String getOwner(String resource) {
+        int lastSlash = resource.lastIndexOf('/');
+        assert lastSlash >= 0;
+        return resource.substring(0, lastSlash);
+    }
+
+    private static boolean canRead(Location loc) {
+        for (Location rl : READ_LOCATIONS) {
+            if (rl.equals(loc)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean canWrite(Location loc) {
+        for (Location wl : WRITE_LOCATIONS) {
+            if (wl.equals(loc)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean canClassLoad(Location loc) {
+        for (Location cll : CLASS_LOADER_LOCATIONS) {
+            if (cll.equals(loc)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    static String convertFQNToResource(String fqn) {
+        return '/' + fqn.replace('.', '/');   //NOI18N
+    }
+
+    static String convertResourceToFQN(String resource) {
+        assert resource.startsWith("/");    //NOI18N
+        int lastSlash = resource.lastIndexOf('/');  //NOI18N
+        int lastDot = resource.lastIndexOf('.');    //NOI18N
+        int stop = lastSlash < lastDot ?
+            lastDot :
+            resource.length();
+        return resource.substring(1, stop).replace('/', '.');    //NOI18N
+    }
+
+
+    JavaFileObject createMemoryFileObject (String resourceName, JavaFileObject.Kind kind, byte[] content) {
+        final InferableJavaFileObject jfo  = new MemoryFileObject(resourceName, kind, content);
+        return jfo;
+    }
+
+    Iterable<? extends MemoryFileObject> getGeneratedFiles(JavaFileObject.Kind... kinds) {
+        final Set<JavaFileObject.Kind> ks = EnumSet.noneOf(JavaFileObject.Kind.class);
+        Collections.addAll(ks, kinds);
+        final List<MemoryFileObject> res = new ArrayList<>();
+        for (Map<String,List<MemoryFileObject>> folders : generated.values()) {
+            for (List<MemoryFileObject> content : folders.values()) {
+                for (MemoryFileObject fo : content) {
+                    if (ks.contains(fo.getKind()) && fo.getLastModified() >= 0) {
+                        res.add(fo);
+                    }
+                }
+            }
+        }
+        return res;
+    }
+
+}