modules/compiler/src/java/flex2/tools/oem/Toolkit.java - flex-sdk - Git at Google

 /*
  *
  *  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 flex2.tools.oem;

 import java.io.BufferedInputStream;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;

 import macromedia.asc.util.ContextStatics;

 import flash.localization.LocalizationManager;
 import flash.swf.Frame;
 import flash.swf.Movie;
 import flash.swf.MovieDecoder;
 import flash.swf.MovieEncoder;
 import flash.swf.TagDecoder;
 import flash.swf.TagEncoder;
 import flash.swf.tags.DefineTag;
 import flash.util.Trace;
 import flex2.compiler.CompilerSwcContext;
 import flex2.compiler.io.LocalFile;
 import flex2.compiler.io.VirtualFile;
 import flex2.compiler.swc.SwcCache;
 import flex2.compiler.util.MimeMappings;
 import flex2.compiler.util.NameMappings;
 import flex2.compiler.util.OrderedProperties;
 import flex2.compiler.util.QName;
 import flex2.compiler.util.SwcDependencyInfo;
 import flex2.compiler.util.SwcDependencyUtil;
 import flex2.compiler.util.SwcExternalScriptInfo;
 import flex2.compiler.util.ThreadLocalToolkit;
 import flex2.compiler.util.Benchmark.MemoryUsage;
 import flex2.compiler.util.graph.Vertex;
 import flex2.tools.oem.OEMException.CircularLibraryDependencyException;
 import flex2.tools.oem.internal.OEMUtil;

 /**
  * A utility class, which supports querying for Application, Library,
  * Component, and Script information, loading properties, optimizing,
  * and querying dependency info.
  * @version 3.0
  */
 public class Toolkit
 {
 	/**
 	 *
 	 * @param application
 	 * @return
 	 */
 	public static ApplicationInfo getApplicationInfo(File application)
 	{
 		InputStream in = null;
 		ApplicationInfo info = null;

 		try
 		{
 			in = new BufferedInputStream(new FileInputStream(application));

 			Movie movie = new Movie();
 			new TagDecoder(in).parse(new MovieDecoder(movie));

 			info = new ApplicationInfoImpl(movie);
 		}
 		catch (IOException ex)
 		{
             if (Trace.error)
             {
                 ex.printStackTrace();
             }
 		}
 		finally
 		{
 			try { if (in != null) in.close(); } catch (IOException ex) {}
 		}

 		return info;
 	}

 	/**
 	 *
 	 * @param library
 	 * @return
 	 */
 	public static LibraryInfo getLibraryInfo(File library)
 	{
 		return getLibraryInfo(new File[] { library });
 	}

 	/**
 	 *
 	 * @param libraries
 	 * @return
 	 */
 	public static LibraryInfo getLibraryInfo(File[] libraries)
 	{
 		return getLibraryInfo(libraries, false);
 	}

 	/**
 	 *
 	 * @param libraries
 	 * @param includeBytecodes
 	 * @return
 	 */
 	public static LibraryInfo getLibraryInfo(File[] libraries, boolean includeBytecodes)
 	{
 		LibraryInfo info = null;

         try
         {
         	OEMUtil.init(OEMUtil.getLogger(null, new ArrayList<Message>()), new MimeMappings(), null, null, null);

             CompilerSwcContext swcContext = new CompilerSwcContext();
             SwcCache cache = new SwcCache();

             swcContext.load(toVirtualFiles(libraries),
 	        				new NameMappings(),
 	        				".properties",
 	        				cache);

             info = new LibraryInfoImpl(swcContext, includeBytecodes);

             swcContext.close();
         }
         catch (Throwable t)
         {
             if (Trace.error)
             {
                 t.printStackTrace();
             }
         }
         finally
         {
         	OEMUtil.clean();
         }

 		return info;
 	}

 	/**
 	 * Converts a list of File(s) into a list of VirtualFile(s).
 	 * The VirtualFile implementation is flex2.compiler.io.LocalFile.
 	 *
 	 * @param files
 	 * @return
 	 */
 	private static VirtualFile[] toVirtualFiles(File[] files)
 	{
 		if (files == null) return null;

 		List<VirtualFile> vFiles = new ArrayList<VirtualFile>(files.length);
 		for (int i = 0; i < files.length; i++)
 		{
 		    if (files[i] != null)
 		        vFiles.add(new LocalFile(files[i]));
 		}

 		return vFiles.toArray(new VirtualFile[vFiles.size()]);
 	}

 	/**
 	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded input stream.
 	 *
 	 * @param in <code>java.io.InputStream</code>
 	 * @return an instance of <code>java.util.Properties</code>;
 	 * 						  <code>null</code> if <code>IOException</code> occurs.
 	 */
 	public static Properties loadProperties(InputStream in)
 	{
 		return loadProperties(in, "UTF-8");
 	}

 	/**
 	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
 	 *
 	 * @param f an <code>UTF-8</code> encoded .properties file
 	 * @return an instance of <code>java.util.Properties</code>;
 	 * 						  <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
 	 */
 	public static Properties loadProperties(File f)
 	{
 		return loadProperties(f, "UTF-8");
 	}

 	/**
 	 * Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
 	 *
 	 * @param f an <code>UTF-8</code> encoded .properties file
 	 * @param encoding character encoding
 	 * @return an instance of <code>java.util.Properties</code>;
 	 * 						  <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
 	 */
 	public static Properties loadProperties(File f, String encoding)
 	{
 		if (f != null && f.isFile())
 		{
 			try
 			{
 				return loadProperties(new FileInputStream(f), encoding);
 			}
 			catch (IOException ex)
 			{
 				return null;
 			}
 		}
 		else
 		{
 			return null;
 		}
 	}

 	private static Properties loadProperties(InputStream in, String encoding)
 	{
 		if (in != null)
 		{
 			try
 			{
 				OrderedProperties p = new OrderedProperties();
 				p.load(new BufferedReader(new InputStreamReader(in, encoding)));
 				return p;
 			}
 			catch (IOException ex)
 			{
 				return null;
 			}
 		}
 		else
 		{
 			return null;
 		}
 	}

 	/**
 	 * Optimizes a SWF. This operation performs the following:
 	 *
 	 * <pre>
 	 * 1. remove debug tags and opcodes
 	 * 2. merge abc bytecodes
 	 * 3. peephole optimization
 	 * 4. remove unwanted metadata
 	 * </pre>
 	 *
 	 * @param in a SWF input stream
 	 * @param out a SWF output stream
 	 * @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
 	 */
 	public static long optimize(InputStream in, OutputStream out)
 	{
 		try
 		{
 			return flex2.tools.WebTierAPI.optimize(in, out);
 		}
 		catch (IOException ex)
 		{
 			return 0;
 		}
 	}

 	/**
 	 * Optimizes the library SWF. This operation performs the following:
 	 *
 	 * <pre>
 	 * 1. remove debug tags and opcodes
 	 * 2. merge abc bytecodes
 	 * 3. peephole optimization
 	 * 4. remove unwanted metadata, but preserve the metadata specified in the Library object
 	 * </pre>
 	 *
 	 * This operation returns an optimized version of the library SWF. The SWF in the library
 	 * remains unchanged.
 	 *
 	 * @param in a SWF input stream
 	 * @param out a SWF output stream
 	 * @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
 	 */
 	public static long optimize(Library lib, OutputStream out)
 	{
 		if (lib == null || lib.data == null || lib.data.movie == null) return 0;

 		try
 		{
 			TagEncoder handler = new TagEncoder();
 			MovieEncoder encoder = new MovieEncoder(handler);
 			encoder.export(lib.data.movie);

             //TODO PERFORMANCE: A lot of unnecessary recopying here
 			ByteArrayOutputStream baos = new ByteArrayOutputStream();
 			handler.writeTo(baos);

 			return flex2.tools.WebTierAPI.optimize(new ByteArrayInputStream(baos.toByteArray()),
 											out,
 											lib.data.configuration);
 		}
 		catch (IOException ex)
 		{
 			return 0;
 		}
 	}

 	/**
 	 *
 	 *
 	 */
 	public static void printMemoryUsage()
 	{
 	    MemoryUsage mem = new flex2.compiler.util.Benchmark().getMemoryUsageInBytes();
 	    long mbHeapUsed = (mem.heap / 1048576);
 		long mbNonHeapUsed = (mem.nonHeap / 1048576);
 		System.out.println("Heap: " + mbHeapUsed + " Non-Heap: " + mbNonHeapUsed);
 	}

 	// added for FB code model
     /**
      * Returns a list filled with namespaces that should be automatically
      * opened, based on the current target player, e.g. flash10, AS3.
      *
      * @param targetPlayerMajorVersion E.g. 9, 10, ...
      * @return List<String> containing the namespaces
      */
     public static List<String> getRequiredUseNamespaces(int targetPlayerMajorVersion)
     {
         return ContextStatics.getRequiredUseNamespaces(targetPlayerMajorVersion);
     }


     /**
      *  The types of dependency the compiler assigns to a symbol. The possible
      *  values are as follows:
      *
      *  <ul>
      *  <li>INHERITANCE
      *  <li>NAMESPACE
      *  <li>SIGNATURE
      *  <li>EXPRESSION
      *  </ul>
      */
     public enum DependencyType {
         /**
          *  The class is used as a base class or is implemented by another
          *  class.
          */
         INHERITANCE ("i"),

         /**
          *  The symbol is a namespace.
          */
         NAMESPACE   ("n"),

         /**
          *  The symbol is used in a function signature.
          */
         SIGNATURE   ("s"),

         /**
          *  The symbol is used in a class or function.
          */
         EXPRESSION  ("e");


         private final String dependency;

         DependencyType(String dependency)
         {
             this.dependency = dependency;
         }

         /**
          *  @return A string that represents the dependency type.
          */
         @Override
         public String toString()
         {
             return dependency;
         }

     }

     /**
      * Get the dependency order of a given set of libraries.
      *
      * @param libraries The set of libraries to find the dependency information for. Each
      * File in the list must be a library file or a directory of libraries files.
      *
      * @return An ordered list of library dependencies. Each String in the
      * list is the location of a library in the file system. The first library in the list has no
      * dependencies. Each library in the list has at least the same dependencies as its
      * predecessor and may be dependent on its predecessor as well.
      */
     public static List<String> getDependencyOrder(File[] libraries) throws CircularLibraryDependencyException
     {
         return getDependencyOrder(libraries, null);
     }

     /**
      * Get the dependency order of a given set of libraries.
      *
      * @param libraries The set of libraries to find the dependency information for. Each
      * File in the list must be a library file or a directory of libraries files.
      * @param dependencySet The types of dependencies to consider when
      * determining the dependency order. If this parameter is null or an empty set, then all
      * dependencies will be considered.
      *
      * @return An ordered list of library dependencies. Each String in the
      * list is the location of a library in the file system. The first library in the list has no
      * dependencies. Each library in the list has at least the same dependencies as its
      * predecessor and may be dependent on its predecessor as well.
      */
     public static List<String> getDependencyOrder(File[] libraries,
             EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
     {
         if (libraries == null)
             return Collections.emptyList();

         // Convert dependencies from an array of DependencyType to an
         // array of String.
         String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
         SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries),
                                                                         stringDependencyTypes,
                                                                         true);
         Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
         if (cycles.size() > 0)
         {
             LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
             if (i10n == null)
             {
                 OEMUtil.setupLocalizationManager();
                 i10n = ThreadLocalToolkit.getLocalizationManager();
             }

             String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
             throw new CircularLibraryDependencyException(message,
                             SwcDependencyUtil.SetOfVertexToString(cycles));
         }

         return info.getSwcDependencyOrder();
     }

     /**
      * Get the set of library dependencies of a given library.
      *
      * @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
      * File in the list must be a library file or a directory of libraries files.
      * @param targetLibrary The libraries to find dependencies for.
      * @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
      * classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
      * classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
      * @return A set of Strings; where each String is the location of a library in the file system.
      */
     public static Set<String> getLibraryDependencies(File[] libraries,
             File targetLibrary,
             boolean minimizeDependencySet) throws CircularLibraryDependencyException
     {
         return getLibraryDependencies(libraries, targetLibrary, minimizeDependencySet, null);
     }

     /**
      * Get the set of library dependencies of a given library.
      *
      * @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
      * File in the list must be a library file or a directory of libraries files.
      * @param targetLibrary The libraries to find dependencies for.
      * @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
      * classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
      * classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
      * @param dependencyTypes The types of dependencies to consider when
      * determining the library's dependencies. If this parameter is null or an empty set, then all
      * dependencies will be considered.
      * @return A set of Strings; where each String is the location of a library in the file system.
      */
     public static Set<String> getLibraryDependencies(File[] libraries,
             File targetLibrary,
             boolean minimizeDependencySet,
             EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
     {
         if (libraries == null || targetLibrary == null)
             return Collections.emptySet();

         // Convert dependencies from an array of DependencyType to an
         // array of String.
         String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
         SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries),
                                                                         stringDependencyTypes,
                                                                         minimizeDependencySet);
         Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
         if (cycles.size() > 0)
         {
             LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
             if (i10n == null)
             {
                 OEMUtil.setupLocalizationManager();
                 i10n = ThreadLocalToolkit.getLocalizationManager();
             }

             String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
             throw new CircularLibraryDependencyException(message,
                             SwcDependencyUtil.SetOfVertexToString(cycles));
         }

         VirtualFile virtualLibrary = new LocalFile(targetLibrary);
         return info.getDependencies(virtualLibrary.getName());
     }

     /**
      * Convert an EnumSet of DependencyType to an Array of Strings.
      *
      * @param dependencySet EnumSet of dependencies to convert.
      * @return Array of Strings. Each string in the Array represents a type of
      * dependency. Returns null if dependencySet is null or an empty set.
      */
     private static String[] dependencyEnumSetToStringArray(EnumSet<DependencyType> dependencySet)
     {
         // Convert dependencies from an array of DependencyType to an
         // array of String.
         String[] stringDependencyTypes = null;
         if (dependencySet != null && dependencySet.size() > 0)
         {
             int n = dependencySet.size();
             int i = 0;
             stringDependencyTypes = new String[n];

             for (DependencyType dependency : dependencySet)
             {
                 stringDependencyTypes[i++] = dependency.toString();
             }
         }

         return stringDependencyTypes;
     }

 }


 /**
  *
  *
  */
 class ApplicationInfoImpl implements ApplicationInfo
 {
     ApplicationInfoImpl(Movie movie)
     {
         version = movie.version;

         List frames = movie.frames;
         Set<String> symbols = new TreeSet<String>();

         for (int i = 0, size = frames == null ? 0 : frames.size(); i < size; i++)
         {
             Frame f = (Frame) frames.get(i);
             for (Iterator j = f.exportIterator(); j.hasNext(); )
             {
                 DefineTag t = (DefineTag) j.next();
                 if (t.name != null)
                 {
                     symbols.add(t.name);
                 }
             }
         }

         symbols.toArray(symbolNames = new String[symbols.size()]);
     }

     private String[] symbolNames;
     private int version;

     public String[] getSymbolNames()
     {
         return symbolNames;
     }

     public int getSWFVersion()
     {
         return version;
     }
 }


 /**
  *
  *
  */
 class LibraryInfoImpl implements LibraryInfo
 {
     LibraryInfoImpl(CompilerSwcContext swcContext, boolean includeBytecodes)
     {
         List<QName> names = new ArrayList<QName>();

         for (Iterator i = swcContext.getDefinitionIterator(); i.hasNext(); )
         {
             names.add((QName) i.next());
         }

         definitionNames = new String[names.size()];

         for (int i = 0; i < definitionNames.length; i++)
         {
             definitionNames[i] = names.get(i).toString();
         }

         scripts = new TreeMap<String, Script>();

         for (int i = 0; i < definitionNames.length; i++)
         {
             QName def = names.get(i);
             Script s = swcContext.getScript(def, includeBytecodes);
             scripts.put(def.toString(), s);
         }

         components = new TreeMap<String, Component>();

         for (Iterator i = swcContext.getComponentIterator(); i.hasNext(); )
         {
             Component c = (Component) i.next();
             components.put(c.getClassName(), c);
         }

         mappings = swcContext.getNameMappings();

         fileNames = new TreeSet<String>(swcContext.getFiles().keySet());
     }

     private String[] definitionNames;
     private Map<String, Script> scripts;
     private Map<String, Component> components;
     private NameMappings mappings;
     private Set<String> fileNames;

     public Component getComponent(String namespaceURI, String name)
     {
         return getComponent(mappings.lookupClassName(namespaceURI, name));
     }

     public Component getComponent(String definition)
     {
         return (definition != null) ? components.get(definition) : null;
     }

     public Iterator<Component> getComponents()
     {
         return components.values().iterator();
     }

     public String[] getDefinitionNames()
     {
         return definitionNames;
     }

     public Script getScript(String definition)
     {
         return scripts.get(definition);
     }

     public Iterator<Script> getScripts()
     {
         return scripts.values().iterator();
     }

     public Iterator<String> getFiles()
     {
         return fileNames.iterator();
     }
 }
	/*
	*
	* 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 flex2.tools.oem;

	import java.io.BufferedInputStream;
	import java.io.BufferedReader;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.EnumSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Properties;
	import java.util.Set;
	import java.util.TreeMap;
	import java.util.TreeSet;

	import macromedia.asc.util.ContextStatics;

	import flash.localization.LocalizationManager;
	import flash.swf.Frame;
	import flash.swf.Movie;
	import flash.swf.MovieDecoder;
	import flash.swf.MovieEncoder;
	import flash.swf.TagDecoder;
	import flash.swf.TagEncoder;
	import flash.swf.tags.DefineTag;
	import flash.util.Trace;
	import flex2.compiler.CompilerSwcContext;
	import flex2.compiler.io.LocalFile;
	import flex2.compiler.io.VirtualFile;
	import flex2.compiler.swc.SwcCache;
	import flex2.compiler.util.MimeMappings;
	import flex2.compiler.util.NameMappings;
	import flex2.compiler.util.OrderedProperties;
	import flex2.compiler.util.QName;
	import flex2.compiler.util.SwcDependencyInfo;
	import flex2.compiler.util.SwcDependencyUtil;
	import flex2.compiler.util.SwcExternalScriptInfo;
	import flex2.compiler.util.ThreadLocalToolkit;
	import flex2.compiler.util.Benchmark.MemoryUsage;
	import flex2.compiler.util.graph.Vertex;
	import flex2.tools.oem.OEMException.CircularLibraryDependencyException;
	import flex2.tools.oem.internal.OEMUtil;

	/**
	* A utility class, which supports querying for Application, Library,
	* Component, and Script information, loading properties, optimizing,
	* and querying dependency info.
	* @version 3.0
	*/
	public class Toolkit
	{
	/**
	*
	* @param application
	* @return
	*/
	public static ApplicationInfo getApplicationInfo(File application)
	{
	InputStream in = null;
	ApplicationInfo info = null;

	try
	{
	in = new BufferedInputStream(new FileInputStream(application));

	Movie movie = new Movie();
	new TagDecoder(in).parse(new MovieDecoder(movie));

	info = new ApplicationInfoImpl(movie);
	}
	catch (IOException ex)
	{
	if (Trace.error)
	{
	ex.printStackTrace();
	}
	}
	finally
	{
	try { if (in != null) in.close(); } catch (IOException ex) {}
	}

	return info;
	}

	/**
	*
	* @param library
	* @return
	*/
	public static LibraryInfo getLibraryInfo(File library)
	{
	return getLibraryInfo(new File[] { library });
	}

	/**
	*
	* @param libraries
	* @return
	*/
	public static LibraryInfo getLibraryInfo(File[] libraries)
	{
	return getLibraryInfo(libraries, false);
	}

	/**
	*
	* @param libraries
	* @param includeBytecodes
	* @return
	*/
	public static LibraryInfo getLibraryInfo(File[] libraries, boolean includeBytecodes)
	{
	LibraryInfo info = null;

	try
	{
	OEMUtil.init(OEMUtil.getLogger(null, new ArrayList<Message>()), new MimeMappings(), null, null, null);

	CompilerSwcContext swcContext = new CompilerSwcContext();
	SwcCache cache = new SwcCache();

	swcContext.load(toVirtualFiles(libraries),
	new NameMappings(),
	".properties",
	cache);

	info = new LibraryInfoImpl(swcContext, includeBytecodes);

	swcContext.close();
	}
	catch (Throwable t)
	{
	if (Trace.error)
	{
	t.printStackTrace();
	}
	}
	finally
	{
	OEMUtil.clean();
	}

	return info;
	}

	/**
	* Converts a list of File(s) into a list of VirtualFile(s).
	* The VirtualFile implementation is flex2.compiler.io.LocalFile.
	*
	* @param files
	* @return
	*/
	private static VirtualFile[] toVirtualFiles(File[] files)
	{
	if (files == null) return null;

	List<VirtualFile> vFiles = new ArrayList<VirtualFile>(files.length);
	for (int i = 0; i < files.length; i++)
	{
	if (files[i] != null)
	vFiles.add(new LocalFile(files[i]));
	}

	return vFiles.toArray(new VirtualFile[vFiles.size()]);
	}

	/**
	* Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded input stream.
	*
	* @param in <code>java.io.InputStream</code>
	* @return an instance of <code>java.util.Properties</code>;
	* <code>null</code> if <code>IOException</code> occurs.
	*/
	public static Properties loadProperties(InputStream in)
	{
	return loadProperties(in, "UTF-8");
	}

	/**
	* Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
	*
	* @param f an <code>UTF-8</code> encoded .properties file
	* @return an instance of <code>java.util.Properties</code>;
	* <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
	*/
	public static Properties loadProperties(File f)
	{
	return loadProperties(f, "UTF-8");
	}

	/**
	* Creates a <code>java.util.Properties</code> object from an <code>UTF-8</code> encoded .properties file.
	*
	* @param f an <code>UTF-8</code> encoded .properties file
	* @param encoding character encoding
	* @return an instance of <code>java.util.Properties</code>;
	* <code>null</code> if the file doesn't exist or if <code>IOException</code> occurs.
	*/
	public static Properties loadProperties(File f, String encoding)
	{
	if (f != null && f.isFile())
	{
	try
	{
	return loadProperties(new FileInputStream(f), encoding);
	}
	catch (IOException ex)
	{
	return null;
	}
	}
	else
	{
	return null;
	}
	}

	private static Properties loadProperties(InputStream in, String encoding)
	{
	if (in != null)
	{
	try
	{
	OrderedProperties p = new OrderedProperties();
	p.load(new BufferedReader(new InputStreamReader(in, encoding)));
	return p;
	}
	catch (IOException ex)
	{
	return null;
	}
	}
	else
	{
	return null;
	}
	}

	/**
	* Optimizes a SWF. This operation performs the following:
	*
	* <pre>
	* 1. remove debug tags and opcodes
	* 2. merge abc bytecodes
	* 3. peephole optimization
	* 4. remove unwanted metadata
	* </pre>
	*
	* @param in a SWF input stream
	* @param out a SWF output stream
	* @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
	*/
	public static long optimize(InputStream in, OutputStream out)
	{
	try
	{
	return flex2.tools.WebTierAPI.optimize(in, out);
	}
	catch (IOException ex)
	{
	return 0;
	}
	}

	/**
	* Optimizes the library SWF. This operation performs the following:
	*
	* <pre>
	* 1. remove debug tags and opcodes
	* 2. merge abc bytecodes
	* 3. peephole optimization
	* 4. remove unwanted metadata, but preserve the metadata specified in the Library object
	* </pre>
	*
	* This operation returns an optimized version of the library SWF. The SWF in the library
	* remains unchanged.
	*
	* @param in a SWF input stream
	* @param out a SWF output stream
	* @return the number of bytes written to the output stream; <code>0</code> if the optimization fails.
	*/
	public static long optimize(Library lib, OutputStream out)
	{
	if (lib == null \|\| lib.data == null \|\| lib.data.movie == null) return 0;

	try
	{
	TagEncoder handler = new TagEncoder();
	MovieEncoder encoder = new MovieEncoder(handler);
	encoder.export(lib.data.movie);

	//TODO PERFORMANCE: A lot of unnecessary recopying here
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	handler.writeTo(baos);

	return flex2.tools.WebTierAPI.optimize(new ByteArrayInputStream(baos.toByteArray()),
	out,
	lib.data.configuration);
	}
	catch (IOException ex)
	{
	return 0;
	}
	}

	/**
	*
	*
	*/
	public static void printMemoryUsage()
	{
	MemoryUsage mem = new flex2.compiler.util.Benchmark().getMemoryUsageInBytes();
	long mbHeapUsed = (mem.heap / 1048576);
	long mbNonHeapUsed = (mem.nonHeap / 1048576);
	System.out.println("Heap: " + mbHeapUsed + " Non-Heap: " + mbNonHeapUsed);
	}

	// added for FB code model
	/**
	* Returns a list filled with namespaces that should be automatically
	* opened, based on the current target player, e.g. flash10, AS3.
	*
	* @param targetPlayerMajorVersion E.g. 9, 10, ...
	* @return List<String> containing the namespaces
	*/
	public static List<String> getRequiredUseNamespaces(int targetPlayerMajorVersion)
	{
	return ContextStatics.getRequiredUseNamespaces(targetPlayerMajorVersion);
	}


	/**
	* The types of dependency the compiler assigns to a symbol. The possible
	* values are as follows:
	*
	* <ul>
	* <li>INHERITANCE
	* <li>NAMESPACE
	* <li>SIGNATURE
	* <li>EXPRESSION
	* </ul>
	*/
	public enum DependencyType {
	/**
	* The class is used as a base class or is implemented by another
	* class.
	*/
	INHERITANCE ("i"),

	/**
	* The symbol is a namespace.
	*/
	NAMESPACE ("n"),

	/**
	* The symbol is used in a function signature.
	*/
	SIGNATURE ("s"),

	/**
	* The symbol is used in a class or function.
	*/
	EXPRESSION ("e");


	private final String dependency;

	DependencyType(String dependency)
	{
	this.dependency = dependency;
	}

	/**
	* @return A string that represents the dependency type.
	*/
	@Override
	public String toString()
	{
	return dependency;
	}

	}

	/**
	* Get the dependency order of a given set of libraries.
	*
	* @param libraries The set of libraries to find the dependency information for. Each
	* File in the list must be a library file or a directory of libraries files.
	*
	* @return An ordered list of library dependencies. Each String in the
	* list is the location of a library in the file system. The first library in the list has no
	* dependencies. Each library in the list has at least the same dependencies as its
	* predecessor and may be dependent on its predecessor as well.
	*/
	public static List<String> getDependencyOrder(File[] libraries) throws CircularLibraryDependencyException
	{
	return getDependencyOrder(libraries, null);
	}

	/**
	* Get the dependency order of a given set of libraries.
	*
	* @param libraries The set of libraries to find the dependency information for. Each
	* File in the list must be a library file or a directory of libraries files.
	* @param dependencySet The types of dependencies to consider when
	* determining the dependency order. If this parameter is null or an empty set, then all
	* dependencies will be considered.
	*
	* @return An ordered list of library dependencies. Each String in the
	* list is the location of a library in the file system. The first library in the list has no
	* dependencies. Each library in the list has at least the same dependencies as its
	* predecessor and may be dependent on its predecessor as well.
	*/
	public static List<String> getDependencyOrder(File[] libraries,
	EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
	{
	if (libraries == null)
	return Collections.emptyList();

	// Convert dependencies from an array of DependencyType to an
	// array of String.
	String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
	SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries),
	stringDependencyTypes,
	true);
	Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
	if (cycles.size() > 0)
	{
	LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
	if (i10n == null)
	{
	OEMUtil.setupLocalizationManager();
	i10n = ThreadLocalToolkit.getLocalizationManager();
	}

	String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
	throw new CircularLibraryDependencyException(message,
	SwcDependencyUtil.SetOfVertexToString(cycles));
	}

	return info.getSwcDependencyOrder();
	}

	/**
	* Get the set of library dependencies of a given library.
	*
	* @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
	* File in the list must be a library file or a directory of libraries files.
	* @param targetLibrary The libraries to find dependencies for.
	* @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
	* classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
	* classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
	* @return A set of Strings; where each String is the location of a library in the file system.
	*/
	public static Set<String> getLibraryDependencies(File[] libraries,
	File targetLibrary,
	boolean minimizeDependencySet) throws CircularLibraryDependencyException
	{
	return getLibraryDependencies(libraries, targetLibrary, minimizeDependencySet, null);
	}

	/**
	* Get the set of library dependencies of a given library.
	*
	* @param libraries The set of libraries need to resolve all the dependencies of the targetLibrary. Each
	* File in the list must be a library file or a directory of libraries files.
	* @param targetLibrary The libraries to find dependencies for.
	* @param minimizeDependencySet If false, all of the libraries dependencies are returned. If true, the external script
	* classes are reviewed. If the set of script classes resolved in a libraryA is a subset of the script
	* classes resolved in libraryB, then libraryA will be removed as a dependency of targetLibrary.
	* @param dependencyTypes The types of dependencies to consider when
	* determining the library's dependencies. If this parameter is null or an empty set, then all
	* dependencies will be considered.
	* @return A set of Strings; where each String is the location of a library in the file system.
	*/
	public static Set<String> getLibraryDependencies(File[] libraries,
	File targetLibrary,
	boolean minimizeDependencySet,
	EnumSet<DependencyType> dependencySet) throws CircularLibraryDependencyException
	{
	if (libraries == null \|\| targetLibrary == null)
	return Collections.emptySet();

	// Convert dependencies from an array of DependencyType to an
	// array of String.
	String[] stringDependencyTypes = dependencyEnumSetToStringArray(dependencySet);
	SwcDependencyInfo info = SwcDependencyUtil.getSwcDependencyInfo(toVirtualFiles(libraries),
	stringDependencyTypes,
	minimizeDependencySet);
	Set<Vertex<String, SwcExternalScriptInfo>> cycles = info.detectCycles();
	if (cycles.size() > 0)
	{
	LocalizationManager i10n = ThreadLocalToolkit.getLocalizationManager();
	if (i10n == null)
	{
	OEMUtil.setupLocalizationManager();
	i10n = ThreadLocalToolkit.getLocalizationManager();
	}

	String message = i10n.getLocalizedTextString(new CircularLibraryDependencyException(null, null));
	throw new CircularLibraryDependencyException(message,
	SwcDependencyUtil.SetOfVertexToString(cycles));
	}

	VirtualFile virtualLibrary = new LocalFile(targetLibrary);
	return info.getDependencies(virtualLibrary.getName());
	}

	/**
	* Convert an EnumSet of DependencyType to an Array of Strings.
	*
	* @param dependencySet EnumSet of dependencies to convert.
	* @return Array of Strings. Each string in the Array represents a type of
	* dependency. Returns null if dependencySet is null or an empty set.
	*/
	private static String[] dependencyEnumSetToStringArray(EnumSet<DependencyType> dependencySet)
	{
	// Convert dependencies from an array of DependencyType to an
	// array of String.
	String[] stringDependencyTypes = null;
	if (dependencySet != null && dependencySet.size() > 0)
	{
	int n = dependencySet.size();
	int i = 0;
	stringDependencyTypes = new String[n];

	for (DependencyType dependency : dependencySet)
	{
	stringDependencyTypes[i++] = dependency.toString();
	}
	}

	return stringDependencyTypes;
	}

	}


	/**
	*
	*
	*/
	class ApplicationInfoImpl implements ApplicationInfo
	{
	ApplicationInfoImpl(Movie movie)
	{
	version = movie.version;

	List frames = movie.frames;
	Set<String> symbols = new TreeSet<String>();

	for (int i = 0, size = frames == null ? 0 : frames.size(); i < size; i++)
	{
	Frame f = (Frame) frames.get(i);
	for (Iterator j = f.exportIterator(); j.hasNext(); )
	{
	DefineTag t = (DefineTag) j.next();
	if (t.name != null)
	{
	symbols.add(t.name);
	}
	}
	}

	symbols.toArray(symbolNames = new String[symbols.size()]);
	}

	private String[] symbolNames;
	private int version;

	public String[] getSymbolNames()
	{
	return symbolNames;
	}

	public int getSWFVersion()
	{
	return version;
	}
	}


	/**
	*
	*
	*/
	class LibraryInfoImpl implements LibraryInfo
	{
	LibraryInfoImpl(CompilerSwcContext swcContext, boolean includeBytecodes)
	{
	List<QName> names = new ArrayList<QName>();

	for (Iterator i = swcContext.getDefinitionIterator(); i.hasNext(); )
	{
	names.add((QName) i.next());
	}

	definitionNames = new String[names.size()];

	for (int i = 0; i < definitionNames.length; i++)
	{
	definitionNames[i] = names.get(i).toString();
	}

	scripts = new TreeMap<String, Script>();

	for (int i = 0; i < definitionNames.length; i++)
	{
	QName def = names.get(i);
	Script s = swcContext.getScript(def, includeBytecodes);
	scripts.put(def.toString(), s);
	}

	components = new TreeMap<String, Component>();

	for (Iterator i = swcContext.getComponentIterator(); i.hasNext(); )
	{
	Component c = (Component) i.next();
	components.put(c.getClassName(), c);
	}

	mappings = swcContext.getNameMappings();

	fileNames = new TreeSet<String>(swcContext.getFiles().keySet());
	}

	private String[] definitionNames;
	private Map<String, Script> scripts;
	private Map<String, Component> components;
	private NameMappings mappings;
	private Set<String> fileNames;

	public Component getComponent(String namespaceURI, String name)
	{
	return getComponent(mappings.lookupClassName(namespaceURI, name));
	}

	public Component getComponent(String definition)
	{
	return (definition != null) ? components.get(definition) : null;
	}

	public Iterator<Component> getComponents()
	{
	return components.values().iterator();
	}

	public String[] getDefinitionNames()
	{
	return definitionNames;
	}

	public Script getScript(String definition)
	{
	return scripts.get(definition);
	}

	public Iterator<Script> getScripts()
	{
	return scripts.values().iterator();
	}

	public Iterator<String> getFiles()
	{
	return fileNames.iterator();
	}
	}