Changeset 3523 for devel-tools/trunk


Ignore:
Timestamp:
Mar 14, 2008, 3:03:43 PM (13 years ago)
Author:
yura
Message:
Location:
devel-tools/trunk/eclipse
Files:
5 edited

Legend:

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

    r3522 r3523  
    2929import org.eclipse.core.resources.ResourcesPlugin;
    3030import org.eclipse.core.runtime.CoreException;
    31 import org.eclipse.core.runtime.IPath;
    3231import org.eclipse.core.runtime.IProgressMonitor;
    3332import org.eclipse.core.runtime.OperationCanceledException;
     
    3534import org.eclipse.jdt.core.IClasspathContainer;
    3635import org.eclipse.jdt.core.IClasspathEntry;
    37 import org.eclipse.jdt.core.IJavaProject;
    3836import org.eclipse.jdt.core.JavaCore;
    3937import org.refal.plus.Expr;
     
    4947
    5048public class RfpBuilder extends IncrementalProjectBuilder {
    51     private void makeClass (String className, byte[] bytes) {
    52         IProject project = getProject();
    53         IJavaProject javaProject = RfpCore.getRfpProject(project).getJavaProject();
    54         try {
    55             IPath projectPath = project.getFullPath();
    56             IPath path = javaProject.getOutputLocation();
    57             if (projectPath.isPrefixOf(path))
    58                 path = path.removeFirstSegments(projectPath.segmentCount());
    59             path = path.append(className.replace('.', '/') + ".class");
    60             IFile classFile = project.getFile(path);
     49    private RfpProject getRfpProject () {
     50        return RfpCore.getRfpProject(getProject());
     51    }
     52   
     53    private void createClassFile (String className, byte[] bytes) {
     54        try {
     55            IFile classFile = getRfpProject().getClassFile(className);
    6156            InputStream inputStream = new ByteArrayInputStream(bytes);
    6257            classFile.create(inputStream, true, null);
     58            classFile.setDerived(true);
    6359            inputStream.close();
    64             classFile.setDerived(true);
    6560        } catch (Exception e) {
     61            RfpCore.log(e);
     62        }
     63    }
     64
     65    private void deleteClassFiles (IFile file) {
     66        RfpProject rfpProject = getRfpProject();
     67        String moduleName = rfpProject.getModuleName(file);
     68        IFile classFile =  rfpProject.getClassFile(moduleName);
     69        try {
     70            for (int i = 0; true; i++) {
     71                if (classFile.exists())
     72                    classFile.delete(true, false, null);
     73                else
     74                    break;
     75                classFile = rfpProject.getClassFile(moduleName + "$" + i);
     76            }
     77        } catch (CoreException e) {
    6678            RfpCore.log(e);
    6779        }
     
    7587            public IdeMsgHandler (IFile implemFile) {
    7688                this.implemFile = implemFile;
    77                 interfFile = RfpBuilder.getSource(project, moduleName, "rfi");
     89                interfFile = project.getSource(moduleName, "rfi");
    7890                RfpBuilder.deleteMarkers(implemFile);
    7991                if (interfFile != null && interfFile.exists())
     
    109121        }
    110122
    111         private final IProject project;
     123        private final RfpProject project;
    112124        private final IdeMsgHandler handler;
    113125        private final String moduleName;
    114126        private final Reader reader;
    115127
    116         public IdeCompilerEnvironment (IProject project, IFile file) {
     128        public IdeCompilerEnvironment (RfpProject project, IFile file) {
    117129            this(project, file, null);
    118130        }
    119131
    120         public IdeCompilerEnvironment (IProject project, IFile file, Reader reader) {
     132        public IdeCompilerEnvironment (RfpProject project, IFile file, Reader reader) {
    121133            this.project = project;
    122             this.moduleName = RfpBuilder.getModuleName(file);
     134            this.moduleName = project.getModuleName(file);
    123135            this.reader = reader;
    124136            this.handler = new IdeMsgHandler(file);
     
    136148            if (this.moduleName.equals(moduleName) && reader != null)
    137149                return reader;
    138             IFile file = RfpBuilder.getSource(project, moduleName, "rf");
     150            IFile file = project.getSource(moduleName, "rf");
    139151            if (file == null || !file.exists())
    140152                return null;
     
    148160
    149161        public Reader getRFIReader (String moduleName) {
    150             IFile file = RfpBuilder.getSource(project, moduleName, "rfi");
     162            IFile file = project.getSource(moduleName, "rfi");
    151163            if (file == null || !file.exists())
    152164                return null;
     
    161173        public Reader getClassReader (String moduleName) {
    162174            try {
    163                 for (IClasspathEntry entry : getClasspathEntries(project))
     175                for (IClasspathEntry entry : project.getJavaProject().getRawClasspath())
    164176                    if (entry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
    165                         IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), RfpCore.getRfpProject(project).getJavaProject());
     177                        IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(),
     178                                project.getJavaProject());
    166179                        for (IClasspathEntry entry2 : container.getClasspathEntries()) {
    167180                            if (entry2.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
     
    190203                sb.append(name);
    191204            }
    192             IFile rfFile = RfpBuilder.getSource(project, getModuleName(), "rf");
     205            IFile rfFile = project.getSource(getModuleName(), "rf");
    193206            try {
    194207                if (rfFile != null)
     
    255268            public boolean visit (IResource resource) throws CoreException {
    256269                if (isRfFile(resource))
    257                     deleteClassFilesForRfFile((IFile) resource);
     270                    deleteClassFiles((IFile) resource);
    258271                return true;
    259272            }
     
    267280        final IFile file = (IFile) resource;
    268281        deleteMarkers(file);
    269         deleteClassFilesForRfFile(file);
    270         final CompilerEnvironment environment = new IdeCompilerEnvironment(getProject(), file);
     282        deleteClassFiles(file);
     283        final CompilerEnvironment environment = new IdeCompilerEnvironment(getRfpProject(), file);
    271284        AstImplem astImplem = Checker.getModuleImplementation(environment);
    272285        if (environment.getMsgHandler().getErrorCount() > 0)
     
    280293                String name = (String) e.at(0);
    281294                Reference<byte[]> jbc = (Reference<byte[]>) e.at(1);
    282                 makeClass(name, jbc.object);
     295                createClassFile(name, jbc.object);
    283296            }
    284297        } catch (org.refal.plus.RefalException e) {
     
    291304            return null;
    292305        deleteMarkers(file);
    293         CompilerEnvironment environment = new IdeCompilerEnvironment(project, file, new StringReader(document));
     306        CompilerEnvironment environment = new IdeCompilerEnvironment(RfpCore.getRfpProject(project), file, new StringReader(document));
    294307        AstImplem astImplem = Checker.getModuleImplementation(environment);
    295308        return astImplem;
     
    314327                if (isRfFile(resource)) {
    315328                    final IFile rfFile = (IFile) resource;
    316                     String moduleName = getModuleName(rfFile);
     329                    String moduleName = getRfpProject().getModuleName(rfFile);
    317330                    SortedSet<String> importedModuleSet = getNamesOfImportedModules(rfFile);
    318331                    for (String importedModule : importedModuleSet) {
     
    344357                    case IResourceDelta.CHANGED:
    345358                        if (isRfFile(resource) || isRfiFile(resource)) {
    346                             SortedSet<String> dependentModuleSet = dependencies.get(getModuleName(resource));
     359                            SortedSet<String> dependentModuleSet = dependencies.get(getRfpProject().getModuleName((IFile) resource));
    347360                            if (dependentModuleSet != null)
    348361                                modulesToRecompile.addAll(dependentModuleSet);
    349362                        }
    350363                        if (isRfFile(resource))
    351                             modulesToRecompile.add(getModuleName(resource));
     364                            modulesToRecompile.add(getRfpProject().getModuleName((IFile) resource));
    352365                        break;
    353366                    default:
     
    369382                return;
    370383            monitor.subTask("Compiling the module " + moduleName);
    371             checkAndCompileModuleImplem(getSource(getProject(), moduleName, "rf"));
     384            checkAndCompileModuleImplem(getRfpProject().getSource(moduleName, "rf"));
    372385            // try {
    373386            // Thread.sleep(1000);
     
    390403    }
    391404
    392     private void deleteClassFilesForRfFile (IFile file) {
    393         IPath classFilePath = file.getProjectRelativePath().removeFileExtension();
    394         IFile classFile = getProject().getFile(classFilePath.addFileExtension("class"));
    395         try {
    396             for (int i = 0; true; i++) {
    397                 if (classFile.exists())
    398                     classFile.delete(true, false, null);
    399                 else
    400                     break;
    401                 classFile = getProject().getFile(classFilePath + "$" + i + ".class");
    402             }
    403         } catch (CoreException e) {
    404             RfpCore.log(e);
    405         }
    406     }
    407 
    408405    private static void deleteMarkers (IFile file) {
    409406        try {
     
    420417                public boolean visit (IResource resource) throws CoreException {
    421418                    if (isRfFile(resource))
    422                         modulesToRecompile.add(getModuleName(resource));
     419                        modulesToRecompile.add(getRfpProject().getModuleName((IFile) resource));
    423420                    return true;
    424421                }
     
    430427    }
    431428
    432     private static IFile getSource (IProject project, String moduleName, String ext) {
    433         IPath projectPath = project.getFullPath();
    434         for (IClasspathEntry entry : getClasspathEntries(project))
    435             if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
    436                 IPath entryPath = entry.getPath();
    437                 if (projectPath.isPrefixOf(entryPath)) {
    438                     IFile file = project.getFile(entryPath.removeFirstSegments(projectPath.segmentCount()).append(
    439                             moduleName.replace('.', '/') + "." + ext));
    440                     if (file.exists())
    441                         return file;
    442                 }
    443             }
    444         return null;
    445     }
    446 
    447     private static IClasspathEntry[] getClasspathEntries (IProject project) {
    448         try {
    449             return RfpCore.getRfpProject(project).getJavaProject().getRawClasspath();
    450         } catch (Exception e) {
    451             RfpCore.log(e);
    452             return new IClasspathEntry[0];
    453         }
    454     }
    455 
    456     private static String getModuleName (IFile file) {
    457         if (!isRfFile(file) && !isRfiFile(file))
    458             throw new IllegalArgumentException();
    459         IPath filePath = file.getFullPath().removeFileExtension();
    460         for (IClasspathEntry entry : getClasspathEntries(file.getProject()))
    461             if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
    462                 IPath entryPath = entry.getPath();
    463                 if (entryPath.isPrefixOf(filePath))
    464                     return filePath.removeFirstSegments(entryPath.segmentCount()).toString().replace('/', '.');
    465             }
    466         return null;
    467     }
    468 
    469     public static String getModuleName (IResource resource) {
    470         if (!(resource instanceof IFile))
    471             throw new IllegalArgumentException();
    472         return getModuleName((IFile) resource);
    473     }
    474 
    475429    private SortedSet<String> getNamesOfImportedModules (IFile file) {
    476430        SortedSet<String> moduleNameSet = new TreeSet<String>();
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpNature.java

    r3522 r3523  
    4545                    entriesNew[i] = JavaCore.newSourceEntry(src.getFullPath());
    4646                }
    47             entriesNew[entriesOld.length + 0] = JavaCore.newContainerEntry(new Path(
    48                     RfpCore.RFP_CONTAINER));
     47            entriesNew[entriesOld.length + 0] = JavaCore.newContainerEntry(new Path(RfpCore.RFP_CONTAINER));
    4948            entriesNew[entriesOld.length + 1] = JavaCore.newContainerEntry(new Path(JavaRuntime.JRE_CONTAINER));
    5049            javaProject.setRawClasspath(entriesNew, null);
    51             javaProject.save(null, true);
    5250            String filters = javaProject.getOption(EXCLUSION_FILTER_ID, true);
    5351            if (filters == null)
     
    5755            filters += EXCLUSION_EXTENTIONS;
    5856            javaProject.setOption(EXCLUSION_FILTER_ID, filters);
     57            javaProject.save(null, true);
    5958        }
    6059    }
  • devel-tools/trunk/eclipse/org.refal.rfpdt.core/src/org/refal/rfpdt/core/RfpProject.java

    r3522 r3523  
    11package org.refal.rfpdt.core;
    22
    3 
     3import org.eclipse.core.resources.IFile;
    44import org.eclipse.core.resources.IProject;
     5import org.eclipse.core.resources.IWorkspaceRoot;
     6import org.eclipse.core.runtime.IPath;
     7import org.eclipse.jdt.core.IClasspathEntry;
    58import org.eclipse.jdt.core.IJavaProject;
    69import org.eclipse.jdt.core.JavaCore;
     
    912    private final IProject project;
    1013    private final IJavaProject javaProject;
     14    private final IWorkspaceRoot workspaceRoot;
    1115
    1216    RfpProject (IProject project) {
    1317        this.project = project;
    1418        this.javaProject = JavaCore.create(project);
     19        this.workspaceRoot = project.getWorkspace().getRoot();
    1520    }
    16    
     21
    1722    public IProject getProject () {
    1823        return project;
     
    2227        return javaProject;
    2328    }
     29
     30    public IFile getClassFile (String moduleName) {
     31        try {
     32            return workspaceRoot.getFile(javaProject.getOutputLocation()
     33                    .append(moduleName.replace('.', '/') + ".class"));
     34        } catch (Exception e) {
     35            RfpCore.log(e);
     36        }
     37        return null;
     38    }
     39
     40    public IFile getSource (String moduleName, String ext) {
     41        try {
     42            for (IClasspathEntry entry : javaProject.getRawClasspath())
     43                if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
     44                    IFile file = workspaceRoot
     45                            .getFile(entry.getPath().append(moduleName.replace('.', '/') + "." + ext));
     46                    if (file.exists())
     47                        return file;
     48                }
     49        } catch (Exception e) {
     50            RfpCore.log(e);
     51        }
     52        return null;
     53    }
     54
     55    public static String staticGetModuleName (IFile file) {
     56        RfpProject rfpProject = RfpCore.getRfpProject(file.getProject());
     57        return rfpProject == null ? null : rfpProject.getModuleName(file);
     58    }
     59
     60    public String getModuleName (IFile file) {
     61        try {
     62            IPath filePath = file.getFullPath().removeFileExtension();
     63            for (IClasspathEntry entry : javaProject.getRawClasspath())
     64                if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
     65                    IPath entryPath = entry.getPath();
     66                    if (entryPath.isPrefixOf(filePath))
     67                        return filePath.removeFirstSegments(entryPath.segmentCount()).toString().replace('/', '.');
     68                }
     69        } catch (Exception e) {
     70            RfpCore.log(e);
     71        }
     72        return null;
     73    }
    2474}
  • devel-tools/trunk/eclipse/org.refal.rfpdt.ui/src/org/refal/rfpdt/ui/actions/ToggleBreakpointAdapter.java

    r3508 r3523  
    44
    55import org.eclipse.core.resources.IFile;
    6 import org.eclipse.core.resources.IResource;
    76import org.eclipse.core.runtime.CoreException;
    87import org.eclipse.core.runtime.IProgressMonitor;
     
    1817import org.eclipse.ui.IWorkbenchPart;
    1918import org.eclipse.ui.texteditor.ITextEditor;
    20 import org.refal.rfpdt.core.RfpBuilder;
     19import org.refal.rfpdt.core.RfpProject;
    2120
    2221public class ToggleBreakpointAdapter implements IToggleBreakpointsTargetExtension {
     
    5251                    }
    5352                    try {
    54                         IResource resource = getFile(part);
    55                         String className = RfpBuilder.getModuleName(resource);
     53                        IFile file = getFile(part);
     54                        String className = RfpProject.staticGetModuleName(file);
    5655                        int lnumber = ((ITextSelection) selection).getStartLine() + 1;
    57                         IJavaLineBreakpoint existingBreakpoint = JDIDebugModel.lineBreakpointExists(resource,
     56                        IJavaLineBreakpoint existingBreakpoint = JDIDebugModel.lineBreakpointExists(file,
    5857                                className, lnumber);
    5958                        if (existingBreakpoint != null) {
     
    6160                            return Status.OK_STATUS;
    6261                        }
    63                         IJavaLineBreakpoint javaLineBreakpoint = JDIDebugModel.createLineBreakpoint(resource,
     62                        IJavaLineBreakpoint javaLineBreakpoint = JDIDebugModel.createLineBreakpoint(file,
    6463                                className, lnumber, -1, -1, 0, true, new HashMap<Object, Object>(10));
    6564                        DebugPlugin.getDefault().getBreakpointManager().addBreakpoint(javaLineBreakpoint);
  • devel-tools/trunk/eclipse/org.refal.rfpdt.ui/src/org/refal/rfpdt/ui/launching/RfpLaunchShortcut.java

    r3520 r3523  
    2424import org.eclipse.ui.IWorkbenchPage;
    2525import org.eclipse.ui.dialogs.ElementListSelectionDialog;
    26 import org.refal.rfpdt.core.RfpBuilder;
     26import org.refal.rfpdt.core.RfpProject;
    2727import org.refal.rfpdt.editor.RfpEditor;
    2828import org.refal.rfpdt.ui.RfpUI;
     
    9898            for (ILaunchConfiguration config : configs)
    9999                if (config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, "").equals(
    100                         RfpBuilder.getModuleName(module))
     100                        RfpProject.staticGetModuleName(module))
    101101                        && config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, "").equals(
    102102                                getWorkingDirectory(module)))
     
    187187        if (module != null) {
    188188            config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, module.getProject().getName());
    189             config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, RfpBuilder.getModuleName(module));
     189            config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, RfpProject.staticGetModuleName(module));
    190190            config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, getWorkingDirectory(module));
    191191        }
Note: See TracChangeset for help on using the changeset viewer.