Changeset 3511 for devel-tools

Timestamp:

Mar 13, 2008, 8:58:24 PM (13 years ago)

Author:

yura

Message:

• Building class-files in bin.

Location:

devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt

Files:

• comp/ExpChecker.java (modified) (1 diff)
• core/RfpBuilder.java (modified) (11 diffs)
• core/RfpNature.java (modified) (2 diffs)

devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/comp/ExpChecker.java

@@ -212 +212 @@
 
     public void visit (AstUse astUse) {
-        astUse.interf.accept(this);
+        if (astUse.interf != null)
+            astUse.interf.accept(this);
     }
 

devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpBuilder.java

@@ -14 +14 @@
 import java.util.TreeMap;
 import java.util.TreeSet;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
 
 import org.eclipse.core.resources.IFile;
@@ -31 +33 @@
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.core.runtime.QualifiedName;
+import org.eclipse.jdt.core.IClasspathContainer;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
 import org.refal.plus.Expr;
 import org.refal.plus.Reference;
@@ -44 +50 @@
 public class RfpBuilder extends IncrementalProjectBuilder {
     private void makeClass (String className, byte[] bytes) {
-        IFile classFile = getIFile(className, "class");
-        InputStream inputStream = new ByteArrayInputStream(bytes);
-        try {
+        IProject project = getProject();
+        IJavaProject javaProject = RfpCorePlugin.getJavaProject(project);
+        try {
+            IPath projectPath = project.getFullPath();
+            IPath path = javaProject.getOutputLocation();
+            if (projectPath.isPrefixOf(path))
+                path = path.removeFirstSegments(projectPath.segmentCount());
+            path = path.append(className.replace('.', '/') + ".class");
+            IFile classFile = project.getFile(path);
+            InputStream inputStream = new ByteArrayInputStream(bytes);
             classFile.create(inputStream, true, null);
             inputStream.close();
@@ -62 +75 @@
             public IdeMsgHandler (IFile implemFile) {
                 this.implemFile = implemFile;
-                interfFile = RfpBuilder.getIFile(project, moduleName, "rfi");
+                interfFile = RfpBuilder.getSource(project, moduleName, "rfi");
                 RfpBuilder.deleteMarkers(implemFile);
-                if (interfFile.exists())
+                if (interfFile != null && interfFile.exists())
                     RfpBuilder.deleteMarkers(interfFile);
             }
@@ -123 +136 @@
             if (this.moduleName.equals(moduleName) && reader != null)
                 return reader;
-            IFile file = RfpBuilder.getIFile(project, moduleName, "rf");
-            if (!file.exists())
+            IFile file = RfpBuilder.getSource(project, moduleName, "rf");
+            if (file == null || !file.exists())
                 return null;
             try {
@@ -135 +148 @@
 
         public Reader getRFIReader (String moduleName) {
-            IFile file = RfpBuilder.getIFile(project, moduleName, "rfi");
-            if (!file.exists())
+            IFile file = RfpBuilder.getSource(project, moduleName, "rfi");
+            if (file == null || !file.exists())
                 return null;
             try {
@@ -147 +160 @@
 
         public Reader getClassReader (String moduleName) {
-            IFile file = RfpBuilder.getIFile(project, moduleName, "class");
-            String formats = null;
             try {
-                if (file.exists()) {
-                    InputStream inputStream = file.getContents();
-                    formats = FormatReader.ReadFormatsFromClass(inputStream);
-                    inputStream.close();
-                } else {
-                    InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(
-                            file.getProjectRelativePath().toString());
-                    if (inputStream != null) {
-                        formats = FormatReader.ReadFormatsFromClass(inputStream);
-                        inputStream.close();
+                for (IClasspathEntry entry : getClasspathEntries(project))
+                    if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
+                        IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), RfpCorePlugin
+                                .getJavaProject(project));
+                        for (IClasspathEntry entry2 : container.getClasspathEntries()) {
+                            if (entry2.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
+                                JarFile jarFile = new JarFile(entry2.getPath().toFile());
+                                JarEntry jarEntry = jarFile.getJarEntry(moduleName.replace('.', '/') + ".class");
+                                if (jarEntry != null) {
+                                    String formats = FormatReader
+                                            .ReadFormatsFromClass(jarFile.getInputStream(jarEntry));
+                                    return formats == null ? null : new StringReader(formats);
+                                }
+                            }
+                        }
                     }
-                }
             } catch (Exception e) {
                 RfpCorePlugin.log(e);
             }
-            return formats == null ? null : new StringReader(formats);
+            return null;
         }
 
@@ -176 +191 @@
                 sb.append(name);
             }
-            IFile rfFile = RfpBuilder.getIFile(project, getModuleName(), "rf");
+            IFile rfFile = RfpBuilder.getSource(project, getModuleName(), "rf");
             try {
-                rfFile.setPersistentProperty(RfpBuilder.IMPORTED_MODULES_PROPKEY, sb.toString());
+                if (rfFile != null)
+                    rfFile.setPersistentProperty(RfpBuilder.IMPORTED_MODULES_PROPKEY, sb.toString());
             } catch (CoreException e) {}
         }
@@ -358 +374 @@
                 return;
             monitor.subTask("Compiling the module " + moduleName);
-            checkAndCompileModuleImplem(getIFile(moduleName, "rf"));
+            checkAndCompileModuleImplem(getSource(getProject(), moduleName, "rf"));
             // try {
             // Thread.sleep(1000);
@@ -419 +435 @@
     }
 
-    private IFile getIFile (String moduleName, String ext) {
-        return getIFile(getProject(), moduleName, ext);
-    }
-
-    private static IFile getIFile (IProject project, String moduleName, String ext) {
-        return project.getFile(moduleName.replace('.', '/') + "." + ext);
+    private static IFile getSource (IProject project, String moduleName, String ext) {
+        IPath projectPath = project.getFullPath();
+        for (IClasspathEntry entry : getClasspathEntries(project))
+            if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
+                IPath entryPath = entry.getPath();
+                if (projectPath.isPrefixOf(entryPath)) {
+                    IFile file = project.getFile(entryPath.removeFirstSegments(projectPath.segmentCount()).append(
+                            moduleName.replace('.', '/') + "." + ext));
+                    if (file.exists())
+                        return file;
+                }
+            }
+        return null;
+    }
+
+    private static IClasspathEntry[] getClasspathEntries (IProject project) {
+        try {
+            return RfpCorePlugin.getJavaProject(project).getRawClasspath();
+        } catch (Exception e) {
+            RfpCorePlugin.log(e);
+            return new IClasspathEntry[0];
+        }
     }
 
@@ -430 +462 @@
         if (!isRfFile(file) && !isRfiFile(file))
             throw new IllegalArgumentException();
-        return file.getProjectRelativePath().removeFileExtension().toString().replace('/', '.');
+        IPath filePath = file.getFullPath().removeFileExtension();
+        for (IClasspathEntry entry : getClasspathEntries(file.getProject()))
+            if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
+                IPath entryPath = entry.getPath();
+                if (entryPath.isPrefixOf(filePath))
+                    return filePath.removeFirstSegments(entryPath.segmentCount()).toString().replace('/', '.');
+            }
+        return null;
     }
 

devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpNature.java

@@ -15 +15 @@
 
 public class RfpNature implements IProjectNature {
+    private static final String EXCLUSION_FILTER_ID = "org.eclipse.jdt.core.builder.resourceCopyExclusionFilter";
+    private static final String EXCLUSION_EXTENTIONS = "*.rf,*.rfi";
+
     public static final String NATURE_ID = "org.refal.rfpdt.core.rfpnature";
 
@@ -50 +53 @@
             javaProject.setRawClasspath(entriesNew, null);
             javaProject.save(null, true);
+            String filters = javaProject.getOption(EXCLUSION_FILTER_ID, true);
+            if (filters == null)
+                filters = "";
+            else if (!filters.equals(""))
+                filters += ",";
+            filters += EXCLUSION_EXTENTIONS;
+            javaProject.setOption(EXCLUSION_FILTER_ID, filters);
         }
     }