Changeset 4135


Ignore:
Timestamp:
Dec 23, 2009, 12:56:52 AM (11 years ago)
Author:
yura
Message:
Location:
devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/compiler/CompilerEnvironment.java

    r4123 r4135  
    99    String getModuleName ();
    1010
     11    /** May return <code>null</code>! */
    1112    Reader getRFReader (String moduleName);
    1213
     14    /** May return <code>null</code>! */
    1315    Reader getRFIReader (String moduleName);
    1416
     17    /** May return <code>null</code>! */
    1518    Reader getREFReader (String moduleName);
    1619
     20    /** May return <code>null</code>! */
    1721    Reader getClassReader (String moduleName);
    1822
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/ICompilerPreferences.java

    r3878 r4135  
    66public interface ICompilerPreferences {
    77    public String QUALIFIER = "org.refal.rfpdt.ui";
    8    
     8
    99    public String PREFIX = "org.refal.rfpdt.editor."; //$NON-NLS-1$
    1010
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpAbstractBuilder.java

    r4133 r4135  
    1919public abstract class RfpAbstractBuilder extends IncrementalProjectBuilder {
    2020    private RfpProject rfpProject;
    21    
     21
    2222    protected RfpProject getRfpProject () {
    2323        if (rfpProject == null)
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpBuilder.java

    r4133 r4135  
    11package org.refal.rfpdt.core;
    22
    3 import java.io.InputStream;
    4 import java.io.InputStreamReader;
    53import java.io.Reader;
    64import java.io.StringReader;
     
    1210import java.util.TreeMap;
    1311import java.util.TreeSet;
    14 import java.util.jar.JarEntry;
    15 import java.util.jar.JarFile;
    1612
    1713import org.eclipse.core.resources.IFile;
     
    2319import org.eclipse.core.resources.IResourceVisitor;
    2420import org.eclipse.core.runtime.CoreException;
    25 import org.eclipse.core.runtime.IPath;
    2621import org.eclipse.core.runtime.IProgressMonitor;
    2722import org.eclipse.core.runtime.QualifiedName;
    28 import org.eclipse.jdt.core.IClasspathContainer;
    29 import org.eclipse.jdt.core.IClasspathEntry;
    30 import org.eclipse.jdt.core.JavaCore;
    31 import org.eclipse.jdt.core.JavaModelException;
    3223import org.refal.plus.Expr;
    3324import org.refal.plus.Native;
     
    3526import org.refal.plus.Reference;
    3627import org.refal.plus.Result;
    37 import org.refal.plus.compiler.FormatReader;
    3828import org.refal.plus.compiler.rfpc;
    3929import org.refal.rfpdt.ast.AstImplem;
     
    124114            if (this.moduleName.equals(moduleName) && reader != null)
    125115                return reader;
    126             IFile file = project.getSource(moduleName, "rf");
    127             if (file == null || !file.exists())
    128                 return null;
    129             try {
    130                 return new InputStreamReader(file.getContents(), file.getCharset());
    131             } catch (Exception e) {
    132                 RfpCore.log(e);
    133                 return null;
    134             }
     116            return project.getSourceReader(moduleName, "rf");
    135117        }
    136118
    137119        public Reader getRFIReader (String moduleName) {
    138             IFile file = project.getSource(moduleName, "rfi");
    139             if (file == null || !file.exists())
    140                 return null;
    141             try {
    142                 return new InputStreamReader(file.getContents(), file.getCharset());
    143             } catch (Exception e) {
    144                 RfpCore.log(e);
    145                 return null;
    146             }
     120            return project.getSourceReader(moduleName, "rfi");
    147121        }
    148122
     
    150124            if (this.moduleName.equals(moduleName) && reader != null)
    151125                return reader;
    152             IFile file = project.getSource(moduleName, "ref");
    153             if (file == null || !file.exists())
    154                 return null;
    155             try {
    156                 return new InputStreamReader(file.getContents(), file.getCharset());
    157             } catch (Exception e) {
    158                 RfpCore.log(e);
    159                 return null;
    160             }
    161         }
    162 
    163         // FIXME: Some thing strange...
    164         private Reader getClassReaderFromLibrary (IClasspathEntry entry, String moduleName) {
    165             if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY)
    166                 return null;
    167             entry = JavaCore.getResolvedClasspathEntry(entry);
    168             IPath path = entry.getPath();
    169             String ext = path.getFileExtension();
    170             if (ext != null && ext.equals("jar")) {
    171                 try {
    172                     JarFile jarFile = null;
    173                     try {
    174                         jarFile = new JarFile(path.toFile());
    175                     } catch (Exception e) {}
    176                     if (jarFile == null)
    177                         try {
    178                             jarFile = new JarFile(project.getFile(path).getRawLocation().toString());
    179                         } catch (Exception e) {}
    180                     if (jarFile == null)
    181                         return null;
    182                     JarEntry jarEntry = jarFile.getJarEntry(moduleName.replace('.', '/') + ".class");
    183                     if (jarEntry == null)
    184                         return null;
    185                     InputStream is = jarFile.getInputStream(jarEntry);
    186                     String formats = FormatReader.ReadFormatsFromClass(is);
    187                     is.close();
    188                     if (formats == null)
    189                         return null;
    190                     return new StringReader(formats);
    191                 } catch (Exception e) {
    192                     RfpCore.log(e);
    193                     return null;
    194                 }
    195             } else {
    196                 IFile file = project.getFile(path.append(moduleName.replace('.', '/') + ".class"));
    197                 if (!file.exists())
    198                     return null;
    199                 String formats;
    200                 try {
    201                     InputStream is = file.getContents();
    202                     formats = FormatReader.ReadFormatsFromClass(is);
    203                     is.close();
    204                 } catch (Exception e) {
    205                     RfpCore.log(e);
    206                     return null;
    207                 }
    208                 if (formats == null)
    209                     return null;
    210                 return new StringReader(formats);
    211             }
     126            return project.getSourceReader(moduleName, "ref");
    212127        }
    213128
    214129        public Reader getClassReader (String moduleName) {
    215             try {
    216                 for (IClasspathEntry entry : project.getJavaProject().getRawClasspath()) {
    217                     if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
    218                         IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project
    219                                 .getJavaProject());
    220                         for (IClasspathEntry entry2 : container.getClasspathEntries()) {
    221                             Reader reader = getClassReaderFromLibrary(entry2, moduleName);
    222                             if (reader != null)
    223                                 return reader;
    224                         }
    225                     } else {
    226                         Reader reader = getClassReaderFromLibrary(entry, moduleName);
    227                         if (reader != null)
    228                             return reader;
    229                     }
    230                 }
    231             } catch (JavaModelException e) {
    232                 RfpCore.log(e);
    233             }
    234             return null;
     130            return project.getClassReader(moduleName);
    235131        }
    236132
     
    279175    @Override
    280176    protected void checkAndCompileModuleImplem (String moduleName) {
    281         IFile file = getRfpProject().getSource(moduleName, "rf");       
    282         IFile file1 = getRfpProject().getSource(moduleName, "ref");       
     177        IFile file = getRfpProject().getSource(moduleName, "rf");
     178        IFile file1 = getRfpProject().getSource(moduleName, "ref");
    283179        if (!RfpProject.isRfFile(file)) {
    284180            if (!RfpProject.isRefFile(file1))
     
    290186        if (file == file1) {
    291187            Checker.getR5(environment);
    292             return;           
     188            return;
    293189        }
    294190        AstImplem astImplem = Checker.getModuleImplementation(environment);
     
    313209
    314210    public static AstImplem checkAndCompileModuleImplem (IProject project, IFile file, String document) {
    315         if (!RfpProject.isRfFile(file) && !RfpProject.isRefFile(file) )
     211        if (!RfpProject.isRfFile(file) && !RfpProject.isRefFile(file))
    316212            return null;
    317213        deleteMarkers(file);
     
    319215            return null;
    320216        if (RfpProject.isRefFile(file)) {
    321             Checker.getR5(new IdeCompilerEnvironment(RfpProject.get(project), file,
    322                     new StringReader(document)));
     217            Checker.getR5(new IdeCompilerEnvironment(RfpProject.get(project), file, new StringReader(document)));
    323218            return null;
    324219        } else
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpCore.java

    r4133 r4135  
    11package org.refal.rfpdt.core;
    2 
    32
    43import org.eclipse.core.runtime.IStatus;
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpPreBuilder.java

    r4125 r4135  
    11package org.refal.rfpdt.core;
    22
    3 import java.io.InputStreamReader;
    43import java.io.Reader;
    5 import java.io.UnsupportedEncodingException;
    64import java.util.Set;
    75
    8 import org.eclipse.core.resources.IFile;
    96import org.eclipse.core.resources.IResource;
    107import org.eclipse.core.runtime.CoreException;
    118import org.eclipse.core.runtime.IProgressMonitor;
    12 import org.eclipse.jdt.core.IClasspathContainer;
    13 import org.eclipse.jdt.core.IClasspathEntry;
    14 import org.eclipse.jdt.core.JavaCore;
    15 import org.eclipse.jdt.core.JavaModelException;
    169import org.refal.rfpdt.ast.AstImplem;
    1710import org.refal.rfpdt.compiler.Checker;
     
    2114
    2215public class RfpPreBuilder extends RfpAbstractBuilder {
    23     private static class IdeCompilerEnvironment implements CompilerEnvironment {
    24         private final RfpProject project;
    25         private final String moduleName;
     16    private class IdeCompilerEnvironment implements CompilerEnvironment {
     17        private String moduleName;
    2618
    27         public IdeCompilerEnvironment (RfpProject project, String moduleName) {
    28             this.project = project;
     19        void setModuleName (String moduleName) {
    2920            this.moduleName = moduleName;
    3021        }
     
    3930
    4031        public Reader getRFReader (String moduleName) {
    41             if (!moduleName.equals(this.moduleName))
    42                 return null;
    43             IFile file = project.getSource(moduleName, "rf");
    44             if (file == null || !file.exists())
    45                 return null;
    46             try {
    47                 return new InputStreamReader(file.getContents(), file.getCharset());
    48             } catch (UnsupportedEncodingException e) {
    49                 RfpCore.log(e);
    50                 return null;
    51             } catch (CoreException e) {
    52                 RfpCore.log(e);
    53                 return null;
    54             }
     32            return moduleName.equals(this.moduleName) ? getRfpProject().getSourceReader(moduleName, "rf") : null;
    5533        }
    5634
    5735        public Reader getREFReader (String moduleName) {
    58                 return null;
    59         }
    60        
    61         public Reader getRFIReader (String moduleName) {
    62             if (!moduleName.equals(this.moduleName))
    63                 return null;
    64             IFile file = project.getSource(moduleName, "rfi");
    65             if (file == null || !file.exists())
    66                 return null;
    67             try {
    68                 return new InputStreamReader(file.getContents(), file.getCharset());
    69             } catch (UnsupportedEncodingException e) {
    70                 RfpCore.log(e);
    71                 return null;
    72             } catch (CoreException e) {
    73                 RfpCore.log(e);
    74                 return null;
    75             }
    76         }
    77 
    78         private Reader getClassReaderFromLibrary (IClasspathEntry entry, String moduleName) {
    7936            return null;
    8037        }
    8138
     39        public Reader getRFIReader (String moduleName) {
     40            return moduleName.equals(this.moduleName) ? getRfpProject().getSourceReader(moduleName, "rfi") : null;
     41        }
     42
    8243        public Reader getClassReader (String moduleName) {
    83             try {
    84                 for (IClasspathEntry entry : project.getJavaProject().getRawClasspath()) {
    85                     if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
    86                         IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), project
    87                                 .getJavaProject());
    88                         for (IClasspathEntry entry2 : container.getClasspathEntries()) {
    89                             Reader reader = getClassReaderFromLibrary(entry2, moduleName);
    90                             if (reader != null)
    91                                 return reader;
    92                         }
    93                     } else {
    94                         Reader reader = getClassReaderFromLibrary(entry, moduleName);
    95                         if (reader != null)
    96                             return reader;
    97                     }
    98                 }
    99             } catch (JavaModelException e) {
    100                 RfpCore.log(e);
    101             }
    10244            return null;
    10345        }
     
    10648    }
    10749
     50    private IdeCompilerEnvironment compilerEnvironment = new IdeCompilerEnvironment();
     51
    10852    protected void checkAndCompileModuleImplem (String moduleName) {
    10953        getRfpProject().deleteClassFiles(moduleName);
    110         IdeCompilerEnvironment env = new IdeCompilerEnvironment(getRfpProject(), moduleName);
    111         AstImplem astImplem = Checker.getModuleImplementation(env);
    112         if (astImplem != null) {
    113             byte[] jbc = RefalInterfaceComplier.compile(astImplem);
    114             getRfpProject().writeClassFile(moduleName, jbc);
    115         }
     54        compilerEnvironment.setModuleName(moduleName);
     55        AstImplem astImplem = Checker.getModuleImplementation(compilerEnvironment);
     56        if (astImplem != null)
     57            getRfpProject().writeClassFile(moduleName, RefalInterfaceComplier.compile(astImplem));
    11658    }
    11759
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpProject.java

    r4133 r4135  
    22
    33import java.io.ByteArrayInputStream;
     4import java.io.File;
     5import java.io.FileInputStream;
     6import java.io.FileNotFoundException;
     7import java.io.IOException;
     8import java.io.InputStream;
     9import java.io.InputStreamReader;
     10import java.io.Reader;
     11import java.io.StringReader;
     12import java.io.UnsupportedEncodingException;
    413import java.util.WeakHashMap;
     14import java.util.jar.JarEntry;
     15import java.util.jar.JarFile;
    516
    617import org.eclipse.core.resources.IFile;
     
    1829import org.eclipse.core.runtime.preferences.IScopeContext;
    1930import org.eclipse.core.runtime.preferences.InstanceScope;
     31import org.eclipse.jdt.core.IClasspathContainer;
    2032import org.eclipse.jdt.core.IClasspathEntry;
    2133import org.eclipse.jdt.core.IJavaProject;
    2234import org.eclipse.jdt.core.JavaCore;
     35import org.eclipse.jdt.core.JavaModelException;
     36import org.refal.plus.compiler.FormatReader;
    2337
    2438public class RfpProject {
     
    5266    }
    5367
    54     private final IProject project;
    5568    private final IJavaProject javaProject;
    5669    private final IWorkspaceRoot workspaceRoot;
     
    5972
    6073    private RfpProject (IProject project) {
    61         this.project = project;
    6274        this.javaProject = JavaCore.create(project);
    6375        this.workspaceRoot = project.getWorkspace().getRoot();
     
    6678    }
    6779
    68     public IProject getProject () {
    69         return project;
    70     }
    71 
    7280    public IJavaProject getJavaProject () {
    7381        return javaProject;
    7482    }
    75    
     83
    7684    public IScopeContext getProjectScope () {
    7785        return projectScope;
    78     }
    79 
    80     public IFile getFile (String fileName) {
    81         return project.getFile(fileName);
    82     }
    83 
    84     public IFile getFile (IPath path) {
    85         return workspaceRoot.getFile(path);
    8686    }
    8787
     
    102102            RfpCore.log(e);
    103103        }
     104    }
     105
     106    /** May return <code>null</code>! */
     107    private IFile getClassFile (String moduleName) {
     108        try {
     109            return getSource(javaProject.getOutputLocation(), moduleName, "class");
     110        } catch (CoreException e) {
     111            RfpCore.log(e);
     112        }
     113        return null;
    104114    }
    105115
     
    156166    }
    157167
    158     /** May return <code>null</code>! */
    159     private IFile getClassFile (String moduleName) {
    160         try {
    161             return getSource(javaProject.getOutputLocation(), moduleName, "class");
    162         } catch (CoreException e) {
    163             RfpCore.log(e);
    164         }
    165         return null;
    166     }
    167 
    168168    public IFile getSource (IPath path, String moduleName, String ext) {
    169169        return workspaceRoot.getFile(path.append(moduleName.replace('.', '/') + "." + ext));
     
    185185    }
    186186
     187    /** May return <code>null</code>! */
     188    public Reader getSourceReader (String moduleName, String ext) {
     189        IFile file = getSource(moduleName, ext);
     190        if (file == null || !file.exists())
     191            return null;
     192        try {
     193            return new InputStreamReader(file.getContents(), file.getCharset());
     194        } catch (CoreException e) {
     195            RfpCore.log(e);
     196            return null;
     197        } catch (UnsupportedEncodingException e) {
     198            RfpCore.log(e);
     199            return null;
     200        }
     201    }
     202
     203    /** May return <code>null</code>! */
     204    private Reader getClassReaderFromLibrary (IClasspathEntry entry, String moduleName) {
     205        if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY)
     206            return null;
     207        String formats = null;
     208        String fileName = moduleName.replace('.', '/') + ".class";
     209        IPath path = JavaCore.getResolvedClasspathEntry(entry).getPath();
     210        String ext = path.getFileExtension();
     211        if (ext != null && ext.equals("jar")) {
     212            JarFile jarFile = null;
     213            try {
     214                File file = path.toFile();
     215                if (file.exists())
     216                    jarFile = new JarFile(file);
     217            } catch (IOException e) {
     218                RfpCore.log(e);
     219            }
     220            try {
     221                IFile file = workspaceRoot.getFile(path);
     222                if (jarFile == null && file.exists())
     223                    jarFile = new JarFile(file.getLocation().toString());
     224            } catch (IOException e) {
     225                RfpCore.log(e);
     226            }
     227            try {
     228                if (jarFile == null)
     229                    return null;
     230                JarEntry jarEntry = jarFile.getJarEntry(fileName);
     231                if (jarEntry == null)
     232                    return null;
     233                InputStream is = jarFile.getInputStream(jarEntry);
     234                formats = FormatReader.ReadFormatsFromClass(is);
     235                is.close();
     236            } catch (IOException e) {
     237                RfpCore.log(e);
     238            }
     239        } else {
     240            path = path.append(fileName);
     241            InputStream is = null;
     242            try {
     243                IFile file = workspaceRoot.getFile(path);
     244                if (file.exists())
     245                    is = file.getContents();
     246            } catch (CoreException e) {
     247                RfpCore.log(e);
     248            }
     249            try {
     250                File file = path.toFile();
     251                if (is == null && file.exists())
     252                    is = new FileInputStream(file);
     253            } catch (FileNotFoundException e) {
     254                RfpCore.log(e);
     255            }
     256            try {
     257                if (is == null)
     258                    return null;
     259                formats = FormatReader.ReadFormatsFromClass(is);
     260                is.close();
     261            } catch (IOException e) {
     262                RfpCore.log(e);
     263            }
     264        }
     265        return formats != null ? new StringReader(formats) : null;
     266    }
     267
     268    /** May return <code>null</code>! */
     269    public Reader getClassReader (String moduleName) {
     270        try {
     271            for (IClasspathEntry entry : javaProject.getRawClasspath())
     272                if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER)
     273                    try {
     274                        IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
     275                        for (IClasspathEntry entry2 : container.getClasspathEntries()) {
     276                            Reader reader = getClassReaderFromLibrary(entry2, moduleName);
     277                            if (reader != null)
     278                                return reader;
     279                        }
     280                    } catch (JavaModelException e) {
     281                        RfpCore.log(e);
     282                    }
     283                else {
     284                    Reader reader = getClassReaderFromLibrary(entry, moduleName);
     285                    if (reader != null)
     286                        return reader;
     287                }
     288        } catch (JavaModelException e) {
     289            RfpCore.log(e);
     290        }
     291        return null;
     292    }
     293
     294    /** May return <code>null</code>! */
    187295    public static String staticGetModuleName (IFile file) {
    188         RfpProject rfpProject = RfpProject.get(file.getProject());
     296        RfpProject rfpProject = get(file.getProject());
    189297        return rfpProject == null ? null : rfpProject.getModuleName(file);
    190298    }
     
    193301    public String getModuleName (IResource file) {
    194302        String extension = file.getFileExtension();
    195         if (file instanceof IFile && extension != null && (extension.equals("rf") || extension.equals("rfi") || extension.equals("ref")))
     303        if (file instanceof IFile && extension != null
     304                && (extension.equals("rf") || extension.equals("rfi") || extension.equals("ref")))
    196305            return getModuleName((IFile) file);
    197306        return null;
Note: See TracChangeset for help on using the changeset viewer.