modules/fdbworkers/src/flash/tools/debugger/concrete/DModule.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package flash.tools.debugger.concrete;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import flash.tools.debugger.NoResponseException;
import flash.tools.debugger.Session;
import flash.tools.debugger.SourceFile;
import flash.tools.debugger.SourceLocator;
import flash.tools.debugger.VersionException;
import flash.util.FileUtils;

/**
 * A module which is uniquly identified by an id, contains
 * a short and long name and also a script
 */
public class DModule implements SourceFile
{
	private ScriptText			m_script;			// lazy-initialized by getScript()
	private boolean				m_gotRealScript;
	private final String		m_rawName;
	private final String		m_shortName;
	private final String		m_path;
	private final String		m_basePath;
	private final int			m_id;
	private final int			m_bitmap;
	private final ArrayList<Integer>		m_line2Offset;
	private final ArrayList<Object>			m_line2Func;		// each array is either null, String, or String[]
	private final HashMap<String, Integer>	m_func2FirstLine;	// maps function name (String) to first line of function (Integer)
	private final HashMap<String, Integer>	m_func2LastLine;	// maps function name (String) to last line of function (Integer)
	private String				m_packageName;
	private boolean				m_gotAllFncNames;
	private int					m_anonymousFunctionCounter = 0;
	private SourceLocator		m_sourceLocator;
	private int					m_sourceLocatorChangeCount;
	private int m_isolateId;
	private final static String	m_newline = System.getProperty("line.separator"); //$NON-NLS-1$

	/**
	 * @param name filename in "basepath;package;filename" format
	 */
	public DModule(SourceLocator sourceLocator, int id, int bitmap, String name, String script, int isolateId)
	{
		// If the caller gave us the script text, then we will create m_script
		// now.  But if the caller gave us an empty string, then we won't bother
		// looking for a disk file until someone actually asks for it.
		if (script != null && script.length() > 0)
		{
			m_script = new ScriptText(script);
			m_gotRealScript = true;
		}

		NameParser nameParser = new NameParser(name);

		m_sourceLocator = sourceLocator;
		m_rawName = name;
		m_basePath = nameParser.getBasePath(); // may be null
		m_bitmap = bitmap;
		m_id = id;
		m_shortName = generateShortName(nameParser);
		m_path = generatePath(nameParser);
		m_line2Offset = new ArrayList<Integer>();
		m_line2Func = new ArrayList<Object>();
		m_func2FirstLine = new HashMap<String, Integer>();
		m_func2LastLine = new HashMap<String, Integer>();
		m_packageName = nameParser.getPackage();
        m_gotAllFncNames = false;
        m_isolateId = isolateId;
	}

	public synchronized ScriptText getScript()
	{
		// If we have been using "dummy" source, and the user has changed the list of
		// directories that are searched for source, then we want to search again
		if (!m_gotRealScript &&
			m_sourceLocator != null &&
			m_sourceLocator.getChangeCount() != m_sourceLocatorChangeCount)
		{
			m_script = null;
		}

		// lazy-initialize m_script, so that we don't read a disk file until
		// someone actually needs to look at the file
		if (m_script == null)
		{
            String script = scriptFromDisk(getRawName());
			if (script == null)
			{
				script = ""; // use dummy source for now //$NON-NLS-1$
			}
			else
			{
				m_gotRealScript = true; // we got the real source
			}
			m_script = new ScriptText(script);
		}
		return m_script;
	}

	/* getters */
	public String		getBasePath()			{ return m_basePath; }
	public String		getName()				{ return m_shortName; }
	public String		getFullPath()			{ return m_path; }
	public String       getPackageName()		{ return (m_packageName == null) ? "" : m_packageName; } //$NON-NLS-1$
	public String		getRawName()			{ return m_rawName; }
	public int			getId()					{ return m_id; }
	public int			getBitmap()				{ return m_bitmap; }
	public int			getLineCount()			{ return getScript().getLineCount(); }
	public String		getLine(int i)			{ return (i > getLineCount()) ? "// code goes here" : getScript().getLine(i); } //$NON-NLS-1$

	void setPackageName(String name)    { m_packageName = name; }

	/**
	 * @return the offset within the swf for a given line 
	 * of source.  0 if unknown.
	 */
	public int getOffsetForLine(int line)
	{ 
		int offset = 0;
		if (line < m_line2Offset.size())
		{
			Integer i = m_line2Offset.get(line);
			if (i != null)
				offset = i.intValue();
		}
		return offset;
	}

	public int getLineForFunctionName(Session s, String name)
	{
		int value = -1;
        primeAllFncNames(s);
		Integer i = m_func2FirstLine.get(name);
		if (i != null)
			value = i.intValue();

		return value;
	}

    /*
     * @see flash.tools.debugger.SourceFile#getFunctionNameForLine(flash.tools.debugger.Session, int)
     */
    public String getFunctionNameForLine(Session s, int line)
    {
        primeFncName(s, line);

    	String[] funcNames = getFunctionNamesForLine(s, line);

    	if (funcNames != null && funcNames.length == 1)
    		return funcNames[0];
    	else
    		return null;
    }

	/**
	 * Return the function names for a given line number, or an empty array
	 * if there are none; never returns <code>null</code>.
	 */
    private String[] getFunctionNamesForLine(Session s, int line)
    {
        primeFncName(s, line);

		if (line < m_line2Func.size())
		{
			Object obj = m_line2Func.get(line);
			
			if (obj instanceof String)
				return new String[] { (String) obj };
			else if (obj instanceof String[])
				return (String[]) obj;
		}

		return new String[0];
    }

	public String[] getFunctionNames(Session s)
	{
		/* find out the size of the array */
        primeAllFncNames(s);
		int count = m_func2FirstLine.size();
		return m_func2FirstLine.keySet().toArray(new String[count]);
	}

	private static String generateShortName(NameParser nameParser)
	{
		String name = nameParser.getOriginalName();
		String s = name;

		if (nameParser.isPathPackageAndFilename()) {
			s = nameParser.getFilename();
		} else {
			/* do we have a file name? */
			int dotAt = name.lastIndexOf('.');
			if (dotAt > 1)
			{
				/* yes let's strip the directory off */
				int lastSlashAt = name.lastIndexOf('\\', dotAt);
				lastSlashAt = Math.max(lastSlashAt, name.lastIndexOf('/', dotAt));
	
				s = name.substring(lastSlashAt+1);
			}
			else
			{
				/* not a file name ... */
				s = name;
			}
		}
		return s.trim();
	}

	/**
	 * Produce a name that contains a file specification including full path.
	 * File names may come in as 'mx.bla : file:/bla.foo.as' or as
	 * 'file://bla.foo.as' or as 'C:\'(?) or as 'basepath;package;filename'
	 */
	private static String generatePath(NameParser nameParser)
	{
		String name = nameParser.getOriginalName();
		String s = name;

		/* strip off first colon of stuff if package exists */
		int colonAt = name.indexOf(':');
		if (colonAt > 1 && !name.startsWith("Actions for")) //$NON-NLS-1$
		{
			if (name.charAt(colonAt+1) == ' ')
				s = name.substring(colonAt+2);
		}
		else if (name.indexOf('.') > -1 && name.charAt(0) != '<' )
		{
			/* some other type of file name */
			s = nameParser.recombine();
		}
		else
		{
			// no path
			s = ""; //$NON-NLS-1$
		}
		return s.trim();
	}

	public void lineMapping(StringBuilder sb)
	{
		Map<String, String> args = new HashMap<String, String>();
		args.put("fileName", getName() ); //$NON-NLS-1$
		args.put("fileNumber", Integer.toString(getId()) ); //$NON-NLS-1$
        sb.append(PlayerSessionManager.getLocalizationManager().getLocalizedTextString("functionsInFile", args)); //$NON-NLS-1$
		sb.append(m_newline);

		String[] funcNames = m_func2FirstLine.keySet().toArray(new String[m_func2FirstLine.size()]);
		Arrays.sort(funcNames, new Comparator<String>() {

			public int compare(String o1, String o2) {
				int line1 = m_func2FirstLine.get(o1).intValue();
				int line2 = m_func2FirstLine.get(o2).intValue();
				return line1 - line2;
			}
			
		});

		for (int i=0; i<funcNames.length; ++i)
		{
			String name = funcNames[i];
			int firstLine = m_func2FirstLine.get(name).intValue();
			int lastLine = m_func2LastLine.get(name).intValue();

			sb.append(" "); //$NON-NLS-1$
			sb.append(name);
			sb.append(" "); //$NON-NLS-1$
			sb.append(firstLine);
			sb.append(" "); //$NON-NLS-1$
			sb.append(lastLine);
			sb.append(m_newline);
		}
	}

    int compareTo(DModule other)
    {
        return getName().compareTo(other.getName());
    }

    /**
     * Called in order to make sure that we have a function name available
     * at the given location.  For AVM+ swfs we don't need a swd and therefore
     * don't have access to function names in the same fashion.
     * We need to ask the player for a particular function name.
     */
    void primeFncName(Session s, int line)
    {
		// for now we do all, optimize later
		primeAllFncNames(s);
    }

    void primeAllFncNames(Session s)
    {
        // send out the request for all functions that the player knows
        // about for this module

        // we block on this call waiting for an answer and after we get it
        // the DManager thread should have populated our mapping tables
        // under the covers.  If its fails then no biggie we just won't
        // see anything in the tables.
        PlayerSession ps = (PlayerSession)s;
        if (!m_gotAllFncNames && ps.playerVersion() >= 9)
        {
            try
            {
                ps.requestFunctionNames(m_id, -1, m_isolateId);
            }
            catch (VersionException e)
            {
                ;
            }
            catch (NoResponseException e)
            {
                ;
            }
        }
        m_gotAllFncNames = true;
    }

	void addLineFunctionInfo(int offset, int line, String funcName)
	{
		addLineFunctionInfo(offset, line, line, funcName);
	}

	/**
	 * Called by DSwfInfo in order to add function name / line / offset mapping
	 * information to the module.  
	 */
	void addLineFunctionInfo(int offset, int firstLine, int lastLine, String funcName)
	{
		int line;

		// strip down the function name
		if (funcName == null || funcName.length() == 0)
		{
			funcName = "<anonymous$" + (++m_anonymousFunctionCounter) + ">"; //$NON-NLS-1$ //$NON-NLS-2$
		}
		else
		{
			// colons or slashes then this is an AS3 name, strip off the core::
			int colon = funcName.lastIndexOf(':');
			int slash = funcName.lastIndexOf('/');
			if (colon > -1 || slash > -1)
			{
				int greater = Math.max(colon, slash);
                funcName = funcName.substring(greater+1);
            }
            else
            {
    			int dot = funcName.lastIndexOf('.');
	    		if (dot > -1)
		    	{
                    // extract function and package
                    String pkg = funcName.substring(0, dot);
                    funcName = funcName.substring(dot+1);

                    // attempt to set the package name while we're in here
                    setPackageName(pkg);
//					System.out.println(m_id+"-func="+funcName+",pkg="+pkg);
                }
            }
		}

//		System.out.println(m_id+"@"+offset+"="+getPath()+".adding func="+funcName);

		// make sure m_line2Offset is big enough for the lines we're about to set
		m_line2Offset.ensureCapacity(firstLine+1);
		while (firstLine >= m_line2Offset.size())
			m_line2Offset.add(null);

		// add the offset mapping
		m_line2Offset.set(firstLine, new Integer(offset));

		// make sure m_line2Func is big enough for the lines we're about to se
		m_line2Func.ensureCapacity(lastLine+1);
		while (lastLine >= m_line2Func.size())
			m_line2Func.add(null);

		// offset and byteCode ignored currently, only add the name for the first hit
		for (line = firstLine; line <= lastLine; ++line)
		{
			Object funcs = m_line2Func.get(line);
			// A line can correspond to more than one function.  The most common case
			// of that is an MXML tag with two event handlers on the same line, e.g.
			//		<mx:Button mouseOver="overHandler()" mouseOut="outHandler()" />;
			// another case is the line that declares an inner anonymous function:
			//		var f:Function = function() { trace('hi') }
			// In any such case, we store a list of function names separated by commas,
			// e.g. "func1, func2"
			if (funcs == null)
			{
				m_line2Func.set(line, funcName);
			}
			else if (funcs instanceof String)
			{
				String oldFunc = (String) funcs;
				m_line2Func.set(line, new String[] { oldFunc, funcName });
			}
			else if (funcs instanceof String[])
			{
				String[] oldFuncs = (String[]) funcs;
				String[] newFuncs = new String[oldFuncs.length + 1];
				System.arraycopy(oldFuncs, 0, newFuncs, 0, oldFuncs.length);
				newFuncs[newFuncs.length - 1] = funcName;
				m_line2Func.set(line, newFuncs);
			}
		}

		// add to our function name list
		if (m_func2FirstLine.get(funcName) == null)
		{
			m_func2FirstLine.put(funcName, new Integer(firstLine));
			m_func2LastLine.put(funcName, new Integer(lastLine));
		}
	}

    /**
     * Scan the disk looking for the location of where the source resides.  May
     * also peel open a swd file looking for the source file.
     * @param name original full path name of the source file
     * @return string containing the contents of the file, or null if not found
     */
    private String scriptFromDisk(String name)
    {
        // we expect the form of the filename to be in the form
        // "c:/src/project;debug;myFile.as"
        // where the semicolons demark the include directory searched by the
        // compiler followed by package directories then file name.
        // any slashes are to be forward slash only!

        // translate to neutral form
        name = name.replace('\\','/');  //@todo remove this when compiler is complete

        // pull the name apart
        final char SEP = ';';
        String pkgPart = ""; //$NON-NLS-1$
        String pathPart = ""; //$NON-NLS-1$
        String namePart = ""; //$NON-NLS-1$
        int at = name.indexOf(SEP);
        if (at > -1)
        {
            // have at least 2 parts to name
            int nextAt = name.indexOf(SEP, at+1);
            if (nextAt > -1)
            {
                // have 3 parts
                pathPart = name.substring(0, at);
                pkgPart = name.substring(at+1, nextAt);
                namePart = name.substring(nextAt+1);
            }
            else
            {
                // 2 parts means no package.
                pathPart = name.substring(0, at);
                namePart = name.substring(at+1);
            }
        }
        else
        {
            // should not be here....
            // trim by last slash
            at = name.lastIndexOf('/');
            if (at > -1)
            {
				// cheat by looking for dirname "mx" in path
				int mx = name.lastIndexOf("/mx/"); //$NON-NLS-1$
				if (mx > -1)
				{
					pathPart = name.substring(0, mx);
					pkgPart = name.substring(mx+1, at);
				}
				else
				{
					pathPart = name.substring(0, at);
				}
				
                namePart = name.substring(at+1);
            }
            else
            {
                pathPart = "."; //$NON-NLS-1$
                namePart = name;
            }
        }

        String script = null;
        try
        {
            // now try to locate the thing on disk or in a swd.
        	Charset realEncoding = null;
        	Charset bomEncoding = null;
        	InputStream in = locateScriptFile(pathPart, pkgPart, namePart);
        	if (in != null)
        	{
        		try
        		{
        			// Read the file using the appropriate encoding, based on
        			// the BOM (if there is a BOM) or the default charset for
        			// the system (if there isn't a BOM)
                    BufferedInputStream bis = new BufferedInputStream( in );
                    bomEncoding = getEncodingFromBOM(bis);
        			script = pullInSource(bis, bomEncoding);

        			// If the file is an XML file with an <?xml> directive,
        			// it may specify a different directive 
        			realEncoding = getEncodingFromXMLDirective(script);
        		}
        		finally
        		{
        			try { in.close(); } catch (IOException e) {}
        		}
        	}
        	
        	// If we found an <?xml> directive with a specified encoding, and
        	// it doesn't match the encoding we used to read the file initially,
        	// start over.
        	if (realEncoding != null && !realEncoding.equals(bomEncoding))
        	{
	            in = locateScriptFile(pathPart, pkgPart, namePart);
	            if (in != null)
	            {
					try
					{
						// Read the file using the real encoding, based on the
						// <?xml...> directive
	                    BufferedInputStream bis = new BufferedInputStream( in );
	                    getEncodingFromBOM(bis);
	        			script = pullInSource(bis, realEncoding);
					}
					finally
					{
						try { in.close(); } catch (IOException e) {}
					}
	            }
        	}
        }
        catch(FileNotFoundException fnf)
        {
            fnf.printStackTrace();  // shouldn't really happen
        }
        return script;
    }

    /**
     * Logic to poke around on disk in order to find the given
     * filename.  We look under the mattress and all other possible
     * places for the silly thing.  We always try locating
     * the file directly first, if that fails then we hunt out
     * the swd.
     */
    InputStream locateScriptFile(String path, String pkg, String name) throws FileNotFoundException
    {
		if (m_sourceLocator != null)
		{
			m_sourceLocatorChangeCount = m_sourceLocator.getChangeCount();
			InputStream is = m_sourceLocator.locateSource(path, pkg, name);
			if (is != null)
				return is;
		}

        // convert slashes first
        path = path.replace('/', File.separatorChar);
        pkg = pkg.replace('/', File.separatorChar);
        File f;

        // use a package base directory if it exists
		if (path.length() > 0)
		{
	        try
	        {
				String pkgAndName = ""; //$NON-NLS-1$
				if (pkg.length() > 0) // have to do this so we don't end up with just "/filename"
					pkgAndName += pkg + File.separatorChar;
				pkgAndName += name;
	            f = new File(path, pkgAndName);
	            if (f.exists())
	                return new FileInputStream(f);
	        }
	        catch(NullPointerException npe)
	        {
	            // skip it.
	        }
		}

        // try the current directory plus package
		if (pkg.length() > 0) // new File("", foo) looks in root directory!
		{
			f = new File(pkg, name);
			if (f.exists())
				return new FileInputStream(f);
		}

        // look in the current directory without the package
        f = new File(name);
        if (f.exists())
            return new FileInputStream(f);

        // @todo try to pry open a swd file...
               
        return null;
    }
    
    /**
     * See if this document starts with a BOM and try to figure
     * out an encoding from it.
     * @param bis		BufferedInputStream for document (so that we can reset the stream
     * 					if we establish that the first characters aren't a BOM)
     * @return			CharSet from BOM (or system default / null)
     */
	private Charset getEncodingFromBOM(BufferedInputStream bis)
	{
		Charset bomEncoding = null;
		bis.mark(3);
		String bomEncodingString;
		try
		{
			bomEncodingString = FileUtils.consumeBOM(bis, null);
		}
		catch (IOException e)
		{
			bomEncodingString = System.getProperty("file.encoding"); //$NON-NLS-1$
		}

		bomEncoding = Charset.forName(bomEncodingString);

		return bomEncoding;
	}

    /**
     * Syntax for an <?xml ...> directive with an encoding (used by getEncodingFromXMLDirective)
     */
    private static final Pattern sXMLDeclarationPattern = Pattern.compile("^<\\?xml[^>]*encoding\\s*=\\s*(\"([^\"]*)\"|'([^']*)')"); //$NON-NLS-1$
    
    /**
     * See if this document starts with an <?xml ...> directive and
     * try to figure out an encoding from it.
     * @param entireSource		source of document
     * @return					specified Charset (or null)
     */
    private Charset getEncodingFromXMLDirective(String entireSource)
    {
    	String encoding = null;
    	Matcher xmlDeclarationMatcher = sXMLDeclarationPattern.matcher(entireSource);
    	if (xmlDeclarationMatcher.find())
    	{
    		encoding = xmlDeclarationMatcher.group(2);
    		if (encoding == null)
    			encoding = xmlDeclarationMatcher.group(3);
    		
    		try
    		{
    			return Charset.forName(encoding);
    		}
    		catch (IllegalArgumentException e)
    		{}
    	}
    	return null;
    }

    /**
     * Given an input stream containing source file contents, read in each line
     * @param in			stream of source file contents (with BOM removed)
     * @param encoding		encoding to use (based on BOM, system default, or <?xml...> directive
     * 						if this is null, the system default will be used)
     * @return				source file contents (as String)
     */
    String pullInSource(InputStream in, Charset encoding)
    {
        String script = ""; //$NON-NLS-1$
        BufferedReader f = null;
        try
        {
        	StringBuilder sb = new StringBuilder();
        	Reader reader = null;
        	if (encoding == null)
        		reader = new InputStreamReader(in);
        	else
        		reader = new InputStreamReader(in, encoding);
            f = new BufferedReader(reader);
            String line;
            while((line = f.readLine()) != null)
            {
                sb.append(line);
                sb.append('\n');
            }
            script = sb.toString();
        }
        catch (IOException e)
        {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        return script;
    }

    /** for debugging */
    @Override
	public String toString()
    {
    	return getFullPath();
    }
 
	/**
	 * Given a filename of the form "basepath;package;filename", return an
	 * array of 3 strings, one for each segment.
	 * @param name a string which *may* be of the form "basepath;package;filename"
	 * @return an array of 3 strings for the three pieces; or, if 'name' is
	 * not of expected form, returns null
	 */
	private static class NameParser
	{
		private String fOriginalName;
		private String fBasePath;
		private String fPackage;
		private String fFilename;
		private String fRecombinedName;

		public NameParser(String name)
		{
			fOriginalName = name;

			/* is it of "basepath;package;filename" format? */
			int semicolonCount = 0;
			int i = 0;
			int firstSemi = -1;
			int lastSemi = -1;
			while ( (i = name.indexOf(';', i)) >= 0 )
			{
				++semicolonCount;
				if (firstSemi == -1)
					firstSemi = i;
				lastSemi = i;
				++i;
			}

			if (semicolonCount == 2)
			{
				fBasePath = name.substring(0, firstSemi);
				fPackage = name.substring(firstSemi+1, lastSemi);
				fFilename = name.substring(lastSemi+1);
			}
		}

		public boolean isPathPackageAndFilename()
		{
			return (fBasePath != null);
		}

		public String getOriginalName()
		{
			return fOriginalName;
		}

		public String getBasePath()
		{
			return fBasePath;
		}

		public String getFilename()
		{
			return fFilename;
		}

		public String getPackage()
		{
			return fPackage;
		}

		/**
		 * Returns a "recombined" form of the original name.
		 * 
		 * For filenames which came in in the form "basepath;package;filename",
		 * the recombined name is the original name with the semicolons replaced
		 * by platform-appropriate slash characters.  For any other type of original
		 * name, the recombined name is the same as the incoming name.
		 */
		public String recombine()
		{
			if (fRecombinedName == null)
			{
				if (isPathPackageAndFilename())
				{
					char slashChar;
					if (fOriginalName.indexOf('\\') != -1)
						slashChar = '\\';
					else
						slashChar = '/';

					fRecombinedName = fOriginalName.replaceAll(";;", ";").replace(';', slashChar); //$NON-NLS-1$ //$NON-NLS-2$
				}
				else
				{
					fRecombinedName = fOriginalName;
				}
			}
			return fRecombinedName;
		}
	}

}