tinydtproject.java

来自「plugin for eclipse」· Java 代码 · 共 626 行 · 第 1/2 页

package isis.tinydt;

import isis.anp.common.ParserConfiguration;
import isis.anp.common.ParserMessage;
import isis.anp.config.ParserConfigurationFactory;
import isis.anp.config.PlatformProfile;
import isis.anp.config.SensorBoardProfile;
import isis.anp.nesc.common.NesCObjectTreeBuilderContext;
import isis.anp.nesc.ot.Configuration;
import isis.anp.nesc.ot.NesCConfigurationFile;
import isis.anp.nesc.ot.NesCFile;
import isis.commons.exec.Executor;
import isis.commons.fs.Dir;
import isis.commons.fs.SearchPath;
import isis.tinydt.editors.nesceditor.NesCEditor;
import isis.tinydt.views.TinydtView;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.QualifiedName;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.console.MessageConsoleStream;



public class TinydtProject
{
        
    public static class Application
    {
        public String configurationFileName         = null;
        public String platform                      = null;
        public String sensorBoard                   = null;
        public String makeOptions                   = null;
        public List   additionalIncludeFolders      = new ArrayList(); // items are strings

        public Application()
        {
        }

        public Application(Application src)
        {
            configurationFileName = new String(src.configurationFileName);
            sensorBoard = src.sensorBoard;
            platform = src.platform;
            makeOptions = src.makeOptions;            
            Iterator it = src.additionalIncludeFolders.iterator();
            while(it.hasNext())
            {
                String folder = (String) it.next();
                additionalIncludeFolders.add(new String(folder));
            }
        }
                                       
        public void generateMakeFile()
        {
            Path p = new Path(configurationFileName);
            String path = Utils.getLocationFromFullResourcePath( p.removeLastSegments(1).toString() );            
            try
            {                
                PrintStream m = new PrintStream(new FileOutputStream(new File(path+"/Makefile2")));
                
                String name = p.segment(p.segmentCount()-1);
                name = name.substring(0,name.length()-3);                
                
                m.println("COMPONENT="+name);
                m.println("include ../Makerules");
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    public static final QualifiedName      TINYDT_PROJECT  = new QualifiedName("isis.tinydt", "tinydtproject");
    public static final String             TINYDT_FILENAME = ".tinydt";
    protected IProject                     project         = null;    
    protected HashMap                      applications    = new HashMap();
    protected String                       currentApp      = null;
    
    private NesCObjectTreeBuilderContext   builderCtx      = null;

    static public TinydtProject getTinydtProject(IProject p)
    {
        TinydtProject proj = null;
        try
        {
            proj = (TinydtProject) p.getSessionProperty(TINYDT_PROJECT);
            if(proj == null)
            {
                proj = new TinydtProject(p);
                p.setSessionProperty(TINYDT_PROJECT, proj);
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return proj;
    }

    static public List getTinydtProjects()
    {
        List tinydtProjects = new ArrayList();
        IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
        for(int i = 0; i < projects.length; ++i)
        {
            try
            {
                if(projects[i].hasNature(TinydtNature.NATURE_ID))
                {
                    TinydtProject project = TinydtProject.getTinydtProject(projects[i]);
                    tinydtProjects.add(project);
                }
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }
        return tinydtProjects;
    }

    public TinydtProject(IProject project)
    {
        this.project = project;
        readTinydtFile();
        parseAll();
    }

    public IProject getProject()
    {
        return project;
    }
    
    public Configuration getCurrentConfiguration()
    {   
        if( currentApp==null )
            return null;
        
        if( builderCtx==null )
            return null;
                
        
        String confFileName = Utils.getLocationFromFullResourcePath( currentApp );
                
        Iterator i = builderCtx.getObjectTrees().iterator();
        while(i.hasNext())
        {
            NesCFile ncf = (NesCFile) i.next();
            if(ncf instanceof NesCConfigurationFile)
            {
                NesCConfigurationFile cf = (NesCConfigurationFile)ncf;
                // we cannot compare directly!! c:\temp != c:/temp
                Path path = new Path(ncf.getFileName());
                
                if( path.toString().equalsIgnoreCase(confFileName) )
                    return (Configuration)cf.getComponent();
            }
        }        
        return null;        
    }
    
    public String getBashPath()
    {
        IPath base_path = TinydtPlugin.getDefault().getStateLocation();
        String file_name = base_path.append("bash.properties").toString();
        try {
        	InputStream is = new FileInputStream( file_name );
        	Properties p = new Properties();
        	p.load(is);
        	if(p.getProperty("bashExecutable")!=null)
        		return p.getProperty("bashExecutable").trim();
        } catch (Exception e) {
        	// sorry - bash.properties does not exist - we return a default value        	
        }
        
        return "c:/tinyos/cygwin/bin/bash.exe";        
    }
    
    public PlatformProfile getPlatformProfile( Application app )
    {
        IPath base_path = TinydtPlugin.getDefault().getStateLocation();
        String file_name = base_path.append(app.platform + ".properties").toString();
        PlatformProfile profile = null;                
        try
        {
            InputStream is = new FileInputStream( file_name );
            profile = PlatformProfile.readObject(is);
        }
        catch( IOException e )
        {
            try
            {
                profile = PlatformProfile.load(app.platform);
            }
            catch( IOException e2 )
            {
                e2.printStackTrace();                
            }            
        }       
        return profile;        
    }
    
    public SensorBoardProfile getSensorBoardProfile( Application app )
    {
        SensorBoardProfile profile = null;                
        try
        {
            profile = SensorBoardProfile.load(app.sensorBoard);
        }
        catch( IOException e2 )
        {
            e2.printStackTrace();                
        }                  
        return profile;        
    }
    
    public SearchPath getSearchPathList( Application app )
    {
        int i;
        
        SearchPath searchPath = new SearchPath();
        
        // add application folder first
        Path p = new Path(app.configurationFileName);
        searchPath.add(Utils.getLocationFromFullResourcePath( p.removeLastSegments(1).toString() ));
        
        // add additional include dirs
        Iterator it = app.additionalIncludeFolders.iterator();
        while( it.hasNext() )
        {
            String s = (String)it.next();
            searchPath.add( Utils.getLocationFromFullResourcePath(s) );
        }
        searchPath.addAll(app.additionalIncludeFolders);                    
        
        return searchPath;
    }
    
    public NesCObjectTreeBuilderContext getObjectTreeCtx()
    {
        return builderCtx;
    }

    public List getNescFileList()
    {
        final List nescFiles = new ArrayList();
        try
        {
            project.accept(new IResourceVisitor()
            {
                public boolean visit(IResource res)
                {
                    if(res instanceof IFolder || res instanceof IProject)
                        return true;
                    if(res instanceof IFile)
                    {
                        IFile file = (IFile) res;
                        System.out.println(file);
                        if(file.getFullPath().getFileExtension() != null
                                && file.getFullPath().getFileExtension().equalsIgnoreCase("nc"))
                        {
                            nescFiles.add(new String(file.getLocation().toString()));
                        }
                    }
                    return false;
                }
            });
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return nescFiles;
    }
    
    /**
     * Makes the application, starting bash and calling make 
     */
    public void makeApplication( Application app )