You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flex.apache.org by ah...@apache.org on 2014/04/06 07:39:41 UTC
[19/26] fork a bunch of files from SDK's FB compiler integration.
Several files are intact,
but many have been gutted to reduce the number of files required. It appears
that the Report isn't used for basic compilation,
so removing all of the compilatio
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/CompilerAPI.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/CompilerAPI.java b/flex-compiler-oem/src/flex2/compiler/CompilerAPI.java
new file mode 100644
index 0000000..00d8376
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/CompilerAPI.java
@@ -0,0 +1,98 @@
+/*
+ *
+ * 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.compiler;
+
+import java.io.File;
+import java.io.IOException;
+
+import flex2.compiler.io.LocalFile;
+import flex2.compiler.io.VirtualFile;
+import flex2.compiler.config.ConfigurationException;
+import flex2.compiler.util.ThreadLocalToolkit;
+import flex2.compiler.common.PathResolver;
+
+/**
+ * This class orchestrates delegation to the subcompilers using
+ * batch1() when -conservative is true or batch2(), the default. It
+ * also handles common tasks like validating CompilationUnit's before
+ * an incremental compilation, resolving dependences, loading a cache
+ * from a previous compilation, and storing a compilation cache.
+ *
+ * @see flex2.compiler.SubCompiler
+ * @see flex2.compiler.PersistentStore
+ * @see flex2.compiler.abc.AbcCompiler
+ * @see flex2.compiler.as3.As3Compiler
+ * @see flex2.compiler.css.CssCompiler
+ * @see flex2.compiler.fxg.FXGCompiler
+ * @see flex2.compiler.i18n.I18nCompiler
+ * @see flex2.compiler.mxml.MxmlCompiler
+ * @author Clement Wong
+ */
+public final class CompilerAPI
+{
+ private final static int INHERITANCE = 1;
+ private final static int NAMESPACES = 2;
+ private final static int TYPES = 3;
+ private final static int EXPRESSIONS = 4;
+
+ static String constructClassName(String namespaceURI, String localPart)
+ {
+ return (namespaceURI.length() == 0) ? localPart : new StringBuilder(namespaceURI.length() + localPart.length() + 1).append(namespaceURI).append(":").append(localPart).toString();
+ }
+ public static VirtualFile getVirtualFile(String path) throws ConfigurationException
+ {
+ return getVirtualFile(path, true);
+ }
+
+ /**
+ * Create virtual file for given file and throw configuration exception if not possible
+ */
+ public static VirtualFile getVirtualFile(String path, boolean reportError) throws ConfigurationException
+ {
+ VirtualFile result = null;
+ File file = new File(path);
+
+ if (file != null && file.exists())
+ {
+ try
+ {
+ result = new LocalFile(file.getCanonicalFile());
+ }
+ catch (IOException e)
+ {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+ else
+ {
+ PathResolver resolver = ThreadLocalToolkit.getPathResolver();
+ result = resolver.resolve(path);
+
+ if (result == null && reportError)
+ {
+ throw new ConfigurationException.IOError(path);
+ }
+ }
+
+ return result;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/CompilerException.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/CompilerException.java b/flex-compiler-oem/src/flex2/compiler/CompilerException.java
new file mode 100644
index 0000000..ec25424
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/CompilerException.java
@@ -0,0 +1,53 @@
+/*
+ *
+ * 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.compiler;
+
+/**
+ * This class provides a common base class for all exceptions thrown
+ * by the compiler. It can be used in catch statements, but it
+ * shouldn't be constructed directly. A subclass of CompilerMessage
+ * should be used when reporting an error or warning.
+ *
+ * @author Clement Wong
+ * @see flex2.compiler.util.CompilerMessage
+ */
+public class CompilerException extends Exception
+{
+ private static final long serialVersionUID = 1587688606009074835L;
+
+ public CompilerException()
+ {
+ }
+
+ public CompilerException(String message)
+ {
+ super(message);
+ }
+
+ public CompilerException(String message, Throwable cause)
+ {
+ super(message, cause);
+ }
+
+ public CompilerException(Throwable cause)
+ {
+ super(cause);
+ }
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/ILocalizableMessage.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/ILocalizableMessage.java b/flex-compiler-oem/src/flex2/compiler/ILocalizableMessage.java
new file mode 100644
index 0000000..d107d94
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/ILocalizableMessage.java
@@ -0,0 +1,35 @@
+/*
+ *
+ * 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.compiler;
+
+/**
+ * This is a marker interface for all localizable messages. All
+ * localized errors and exceptions should implement this.
+ *
+ * @author Roger Gonzalez
+ */
+public interface ILocalizableMessage extends flex2.tools.oem.Message
+{
+ void setPath(String path);
+ void setLine(int line);
+ void setColumn(int column);
+ Exception getExceptionDetail();
+ boolean isPathAvailable();
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/Logger.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/Logger.java b/flex-compiler-oem/src/flex2/compiler/Logger.java
new file mode 100644
index 0000000..2b5e90f
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/Logger.java
@@ -0,0 +1,94 @@
+/*
+ *
+ * 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.compiler;
+
+//import flash.localization.LocalizationManager;
+
+/**
+ * The base interface of all loggers in the compiler.
+ *
+ * @author Clement Wong
+ */
+public interface Logger
+{
+ int errorCount();
+
+ int warningCount();
+
+ void logInfo(String info);
+
+ void logDebug(String debug);
+
+ void logWarning(String warning);
+
+ void logError(String error);
+
+ void logInfo(String path, String info);
+
+ void logDebug(String path, String debug);
+
+ void logWarning(String path, String warning);
+
+ void logWarning(String path, String warning, int errorCode);
+
+ void logError(String path, String error);
+
+ void logError(String path, String error, int errorCode);
+
+ void logInfo(String path, int line, String info);
+
+ void logDebug(String path, int line, String debug);
+
+ void logWarning(String path, int line, String warning);
+
+ void logWarning(String path, int line, String warning, int errorCode);
+
+ void logError(String path, int line, String error);
+
+ void logError(String path, int line, String error, int errorCode);
+
+ void logInfo(String path, int line, int col, String info);
+
+ void logDebug(String path, int line, int col, String debug);
+
+ void logWarning(String path, int line, int col, String warning);
+
+ void logError(String path, int line, int col, String error);
+
+ void logWarning(String path, int line, int col, String warning, String source);
+
+ void logWarning(String path, int line, int col, String warning, String source, int errorCode);
+
+ void logError(String path, int line, int col, String error, String source);
+
+ void logError(String path, int line, int col, String error, String source, int errorCode);
+
+ void log(ILocalizableMessage m);
+
+ void log(ILocalizableMessage m, String source);
+
+ void needsCompilation(String path, String reason);
+
+ void includedFileUpdated(String path);
+
+ void includedFileAffected(String path);
+
+// void setLocalizationManager( LocalizationManager mgr );
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/Source.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/Source.java b/flex-compiler-oem/src/flex2/compiler/Source.java
new file mode 100644
index 0000000..a610047
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/Source.java
@@ -0,0 +1,127 @@
+/*
+ *
+ * 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.compiler;
+
+import flex2.compiler.io.VirtualFile;
+import java.util.*;
+
+/**
+ * This class represents the information associated with a single file
+ * while it's being compiled. This information includes the
+ * <code>pathRoot</code>, the <code>relativePath</code>, the
+ * <code>shortName</code>, which is often the class name, the owner,
+ * which specifies where the Source came from, and whether the
+ * <code>Source</code> is internal, root, and debuggable.
+ *
+ * @author Clement Wong
+ */
+public final class Source implements Comparable<Source>
+{
+ // used by flex2.compiler.i18n.I18nCompiler, InterfaceCompiler and ImplementationCompiler
+ public Source(VirtualFile file, Source original)
+ {
+ this(file, original.pathRoot, original.relativePath, original.shortName, original.owner, original.isInternal, original.isRoot, original.isDebuggable);
+ this.delegate = original;
+ }
+
+ // used by InterfaceCompiler.createInlineComponentUnit(). Note the owner will be set
+ // later by the ResourceContainer when this is passed into addResource() by
+ // CompilerAPI.addGeneratedSources().
+ public Source(VirtualFile file, Source original, String shortName, boolean isInternal, boolean isRoot)
+ {
+ this(file, original.pathRoot, original.relativePath, shortName, null, isInternal, isRoot, true);
+ this.delegate = original;
+ }
+
+ // used by FileSpec
+ public Source(VirtualFile file, String relativePath, String shortName, Object owner, boolean isInternal, boolean isRoot)
+ {
+ this(file, null, relativePath, shortName, owner, isInternal, isRoot, true);
+ }
+
+ // used by SourceList and SourcePath
+ public Source(VirtualFile file, VirtualFile pathRoot, String relativePath, String shortName, Object owner, boolean isInternal, boolean isRoot)
+ {
+ this(file, pathRoot, relativePath, shortName, owner, isInternal, isRoot, true);
+ }
+
+ // used by StylesContainer, CompilerSwcContext, EmbedEvaluator, DataBindingExtension and PreLink
+ public Source(VirtualFile file, String relativePath, String shortName, Object owner, boolean isInternal, boolean isRoot, boolean isDebuggable)
+ {
+ this(file, null, relativePath, shortName, owner, isInternal, isRoot, isDebuggable);
+ }
+
+ Source(VirtualFile file, VirtualFile pathRoot, String relativePath, String shortName, Object owner, boolean isInternal, boolean isRoot, boolean isDebuggable)
+ {
+ this.file = file;
+ this.pathRoot = pathRoot;
+ this.relativePath = relativePath;
+ this.shortName = shortName;
+ this.owner = owner;
+ this.isInternal = isInternal;
+ this.isRoot = isRoot;
+ this.isDebuggable = isDebuggable;
+
+ if (file != null)
+ {
+ fileTime = file.getLastModified();
+ }
+
+ fileIncludeTimes = new HashMap<VirtualFile, Long>(4);
+ }
+
+ private VirtualFile file;
+ private VirtualFile pathRoot;
+ private String relativePath, shortName;
+ private Object owner;
+ private boolean isInternal;
+ private boolean isRoot;
+ private boolean isDebuggable;
+ private boolean isPreprocessed;
+
+ private long fileTime;
+ private Map<VirtualFile, Long> fileIncludeTimes;
+
+ // 1. path resolution
+ // 2. backing file
+ // 3. source fragments
+ private Source delegate;
+
+ public int compareTo(Source source)
+ {
+ return getName().compareTo(source.getName());
+ }
+
+ public String getName()
+ {
+ return file.getName();
+ }
+
+ public String getNameForReporting()
+ {
+ return file.getNameForReporting();
+ }
+
+ public boolean exists()
+ {
+ return file.getLastModified() > 0;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/SourceList.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/SourceList.java b/flex-compiler-oem/src/flex2/compiler/SourceList.java
new file mode 100644
index 0000000..1e2e3e0
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/SourceList.java
@@ -0,0 +1,370 @@
+/*
+ *
+ * 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.compiler;
+
+import flex2.compiler.io.FileUtil;
+import flex2.compiler.io.LocalFile;
+import flex2.compiler.io.VirtualFile;
+import flex2.compiler.util.CompilerMessage;
+import flex2.compiler.util.NameFormatter;
+import flex2.compiler.util.QName;
+import flex2.compiler.util.ThreadLocalToolkit;
+import flex2.tools.oem.ApplicationCache;
+
+import java.io.File;
+import java.util.*;
+
+/**
+ * A SourceList represents a list of files, following the single
+ * public definition rule, and an associated path where dependencies
+ * can be found. When compiling via mxmlc, the files specified on the
+ * command line are put into the <code>SourceList</code>. When
+ * compiling via Flash Builder, the root or application is included in
+ * the <code>SourceList</code>.
+ *
+ * @author Clement Wong
+ */
+public final class SourceList
+{
+ public SourceList(List<VirtualFile> files, VirtualFile[] classPath, VirtualFile appPath, String[] mimeTypes)
+ throws CompilerException
+ {
+ this(files, classPath, appPath, mimeTypes, true);
+ }
+
+ public SourceList(List<VirtualFile> files, VirtualFile[] classPath, VirtualFile appPath, String[] mimeTypes, boolean lastIsRoot)
+ throws CompilerException
+ {
+ VirtualFile[] vfiles = new VirtualFile[files.size()];
+ files.toArray(vfiles);
+ init(vfiles, classPath, appPath, mimeTypes, lastIsRoot);
+ }
+
+ private void init(VirtualFile[] files, VirtualFile[] classPath, VirtualFile appPath, String[] mimeTypes, boolean lastIsRoot)
+ throws CompilerException
+ {
+ this.mimeTypes = mimeTypes;
+ sources = new LinkedHashMap<String, Source>(files.length);
+ directories = new ArrayList<File>(classPath == null ? 0 : classPath.length);
+
+ SourcePath.addApplicationParentToSourcePath(appPath, classPath, directories);
+ SourcePath.addPathElements(classPath, directories, true, null);
+
+ for (int i = 0, length = files.length; i < length; i++)
+ {
+ // No need to check to see if the appPath is supported again.
+ if ((appPath != null && files[i].getName().equals(appPath.getName())) || isSupported(files[i]))
+ {
+ String name = files[i].getName();
+ VirtualFile pathRoot = calculatePathRoot(files[i]);
+ if (pathRoot != null)
+ {
+ String relativePath = calculateRelativePath(name);
+ String namespaceURI = relativePath.replace('/', '.');
+ String localPart = calculateLocalPart(name);
+ Source source = new Source(files[i], pathRoot, relativePath, localPart, this, false, (i == length - 1) && lastIsRoot);
+ String className = CompilerAPI.constructClassName(namespaceURI, localPart);
+ sources.put(className, source);
+ }
+ else
+ {
+ // Files in SourceList must be in --source-path.
+ // output an error here...
+ FileNotInSourcePath ex = new FileNotInSourcePath(name);
+ ThreadLocalToolkit.log(ex);
+ throw ex;
+ }
+ }
+ else
+ {
+ UnsupportedFileType ex = new UnsupportedFileType(files[i].getName());
+ ThreadLocalToolkit.log(ex);
+ throw ex;
+ }
+ }
+ }
+
+ private VirtualFile calculatePathRoot(VirtualFile f)
+ {
+ return calculatePathRoot(f, directories);
+ }
+
+ static VirtualFile calculatePathRoot(VirtualFile f, List<File> directories)
+ {
+ String name = f.getName();
+ for (int i = 0, size = directories == null ? 0 : directories.size(); i < size; i++)
+ {
+ String dir = directories.get(i).getAbsolutePath();
+ if (name.startsWith(dir))
+ {
+ return new LocalFile(FileUtil.openFile(dir));
+ }
+ }
+ // return new LocalFile(FileUtil.openFile(f.getParent()));
+ return null;
+ }
+
+ private String calculateRelativePath(String name)
+ {
+ // C: name is canonical.
+ for (int i = 0, size = directories == null ? 0 : directories.size(); i < size; i++)
+ {
+ // Tack on the separatorChar to handle directories, which
+ // are the same as other, just longer. Like "a" and "a1".
+ // See SDK-24084.
+ String dir = directories.get(i).getAbsolutePath() + File.separatorChar;
+
+ if (name.startsWith(dir))
+ {
+ name = name.substring(dir.length());
+ int index = name.lastIndexOf(File.separatorChar);
+ if (index != -1)
+ {
+ return name.substring(0, index).replace(File.separatorChar, '/');
+ }
+ else
+ {
+ return "";
+ }
+ }
+ }
+
+ return "";
+ }
+
+ private String calculateLocalPart(String name)
+ {
+ String leafName = name.substring(name.lastIndexOf(File.separatorChar) + 1);
+ String localPart = leafName.substring(0, leafName.lastIndexOf('.'));
+ return localPart;
+ }
+
+ private Map<String, Source> sources;
+ private List<File> directories;
+ private String[] mimeTypes;
+
+ public List<Source> retrieveSources()
+ {
+ List<Source> sources = new ArrayList<Source>(this.sources.size());
+
+ for (Iterator<String> i = this.sources.keySet().iterator(); i.hasNext();)
+ {
+ String name = i.next();
+ Source s = this.sources.get(name);
+// CompilationUnit u = (s != null) ? s.getCompilationUnit() : null;
+
+ if (s != null && !s.exists())
+ {
+ // C: This is a SourceList. If the source doesn't exist, the compiler should get a warning...
+ s = null;
+ }
+ // else if ((u != null && !u.isDone()) || (s != null && s.isUpdated()))
+ // {
+ // s.removeCompilationUnit();
+ // }
+ // else if (u != null)
+ // {
+ // s = s.copy();
+ // assert s != null;
+ // }
+
+ if (s != null)
+ {
+ sources.add(s);
+ }
+ }
+
+ return sources;
+ }
+
+ /*
+ public Source findSource(String namespaceURI, String localPart)
+ {
+ if (sources.size() == 0)
+ {
+ return null;
+ }
+
+ assert localPart.indexOf('.') == -1 && localPart.indexOf('/') == -1 && localPart.indexOf(':') == -1
+ : "findSource(" + namespaceURI + "," + localPart + ") has bad localPart";
+
+ // classname format is a.b:c
+ String className = CompilerAPI.constructClassName(namespaceURI, localPart);
+ Source s = sources.get(className);
+ CompilationUnit u = (s != null) ? s.getCompilationUnit() : null;
+
+ if (s != null && !s.exists())
+ {
+ s = null;
+ }
+
+ // If the compilation unit does exist and the top level definition name doesn't match
+ // the specified class name, we don't count it as a match.
+ if (s != null && u != null && u.topLevelDefinitions.size() == 1)
+ {
+ if (!u.topLevelDefinitions.contains(namespaceURI, localPart))
+ {
+ String realName = u.topLevelDefinitions.first().toString();
+ sources.put(realName, s);
+ s = null;
+ u = null;
+ }
+ }
+
+ if (s != null && ((u != null && !u.isDone()) || s.isUpdated()))
+ {
+ // s.removeCompilationUnit();
+ }
+ else if (s != null && u != null)
+ {
+ s = s.copy();
+ assert s != null;
+ }
+
+ return s;
+ }
+
+ String[] checkClassNameFileName(Source s)
+ {
+ String defName = null, pathName = null;
+
+ if (s.getOwner() == this)
+ {
+ QName def = s.getCompilationUnit().topLevelDefinitions.last();
+
+ defName = def.getLocalPart();
+ pathName = s.getShortName();
+
+ if (defName.equals(pathName))
+ {
+ return null;
+ }
+ }
+
+ return new String[] { pathName, defName };
+ }
+
+ String[] checkPackageNameDirectoryName(Source s)
+ {
+ String defPackage = null, pathPackage = null;
+
+ if (s.getOwner() == this)
+ {
+ QName def = s.getCompilationUnit().topLevelDefinitions.last();
+
+ defPackage = NameFormatter.normalizePackageName(def.getNamespace());
+ pathPackage = NameFormatter.toDot(s.getRelativePath(), '/');
+
+ if (defPackage.equals(pathPackage))
+ {
+ return null;
+ }
+ }
+
+ return new String[] { pathPackage, defPackage };
+ }
+ */
+ private boolean isSupported(VirtualFile file)
+ {
+ for (int i = 0, length = mimeTypes.length; i < length; i++)
+ {
+ if (mimeTypes[i].equals(file.getMimeType()))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public List<File> getPaths()
+ {
+ return directories;
+ }
+
+ String[] getMimeTypes()
+ {
+ return mimeTypes;
+ }
+
+ /**
+ * Checks if there is a cached Source for each local Source and if
+ * found, copies it's CompilationUnit into it.
+ public void applyApplicationCache(ApplicationCache applicationCache)
+ {
+ for (Map.Entry<String, Source> entry : sources.entrySet())
+ {
+ String className = entry.getKey();
+ Source source = entry.getValue();
+ Source cachedSource = applicationCache.getSource(className);
+
+ if ((cachedSource != null) && !cachedSource.isUpdated())
+ {
+ CompilationUnit cachedCompilationUnit = cachedSource.getCompilationUnit();
+
+ if (cachedSource.getPathRoot().equals(source.getPathRoot()) &&
+ (cachedCompilationUnit != null) && cachedCompilationUnit.hasTypeInfo)
+ {
+ CompilationUnit compilationUnit =
+ source.newCompilationUnit(cachedCompilationUnit.getSyntaxTree(),
+ new CompilerContext());
+
+ Source.copyCompilationUnit(cachedCompilationUnit, compilationUnit, true);
+ source.setFileTime(cachedSource.getFileTime());
+ cachedSource.reused();
+ }
+ }
+ }
+ }
+ */
+
+ public Map<String, Source> sources()
+ {
+ return sources;
+ }
+
+ // error messages
+
+ public static class FileNotInSourcePath extends CompilerMessage.CompilerError
+ {
+ private static final long serialVersionUID = -1516975612657669682L;
+
+ public FileNotInSourcePath(String name)
+ {
+ super();
+ this.name = name;
+ }
+
+ public final String name;
+ }
+
+ public static class UnsupportedFileType extends CompilerMessage.CompilerError
+ {
+ private static final long serialVersionUID = 5300063184460255877L;
+
+ public UnsupportedFileType(String name)
+ {
+ super();
+ this.name = name;
+ }
+
+ public final String name;
+ }
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/SourcePath.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/SourcePath.java b/flex-compiler-oem/src/flex2/compiler/SourcePath.java
new file mode 100644
index 0000000..4e356a0
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/SourcePath.java
@@ -0,0 +1,647 @@
+/*
+ *
+ * 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.compiler;
+
+import flex2.compiler.common.SinglePathResolver;
+import flex2.compiler.io.FileUtil;
+import flex2.compiler.io.LocalFile;
+import flex2.compiler.io.VirtualFile;
+import flex2.compiler.util.CompilerMessage;
+import flex2.compiler.util.MimeMappings;
+import flex2.compiler.util.NameFormatter;
+import flex2.compiler.util.QName;
+import flex2.compiler.util.ThreadLocalToolkit;
+import flex2.tools.oem.ApplicationCache;
+
+import java.io.File;
+import java.util.*;
+
+/**
+ * A list of paths specified by the -source-path option, where
+ * dependencies, following the single public definition rule, can be
+ * resolved.
+ *
+ * @author Clement Wong
+ */
+public class SourcePath extends SourcePathBase
+ implements SinglePathResolver
+{
+ protected final List<File> directories;
+ private ApplicationCache applicationCache;
+
+ public SourcePath(VirtualFile[] classPath, VirtualFile appPath, String[] mimeTypes, boolean allowSourcePathOverlap)
+ {
+ this(mimeTypes, allowSourcePathOverlap);
+
+ addApplicationParentToSourcePath(appPath, classPath, this.directories);
+ addPathElements(classPath, this.directories, allowSourcePathOverlap, warnings);
+ }
+
+ public SourcePath(String[] mimeTypes, boolean allowSourcePathOverlap)
+ {
+ super(mimeTypes, allowSourcePathOverlap);
+ directories = new LinkedList<File>();
+ }
+
+ public void addPathElements(VirtualFile[] classPath)
+ {
+ addPathElements(classPath, directories, allowSourcePathOverlap, warnings);
+ }
+
+ /*
+ private Source newSource(File file, File pathRoot, String namespaceURI, String localPart)
+ {
+ Source source = new Source(new LocalFile(file), new LocalFile(pathRoot),
+ namespaceURI.replace('.', '/'), localPart, this, false, false);
+
+ if (applicationCache != null)
+ {
+ String className = CompilerAPI.constructClassName(namespaceURI, localPart);
+ Source cachedSource = applicationCache.getSource(className);
+
+ if ((cachedSource != null) && !cachedSource.isUpdated())
+ {
+ CompilationUnit cachedCompilationUnit = cachedSource.getCompilationUnit();
+
+ if (cachedSource.getPathRoot().equals(source.getPathRoot()) &&
+ (cachedCompilationUnit != null) && cachedCompilationUnit.hasTypeInfo)
+ {
+ CompilationUnit compilationUnit =
+ source.newCompilationUnit(cachedCompilationUnit.getSyntaxTree(),
+ new CompilerContext());
+
+ Source.copyCompilationUnit(cachedCompilationUnit, compilationUnit, true);
+ source.setFileTime(cachedSource.getFileTime());
+ cachedSource.reused();
+
+ // We somehow need to validate that other reused
+ // sources, which depend on this source, reference
+ // the same slots. Or maybe it's good enough just
+ // to validate that the slots referenced by this
+ // source are the same as the slots referenced by
+ // the dependencies. Something to ponder.
+ }
+ }
+ }
+
+ return source;
+ }
+
+ // see if the Source object continues to be the first choice given a QName.
+ boolean checkPreference(Source s)
+ {
+ assert s.getOwner() == this;
+
+ String relativePath = constructRelativePath(s), pathRoot = s.getPathRoot().getName();
+ if (relativePath == null)
+ {
+ // not possible, but don't disrupt the flow...
+ return true;
+ }
+
+ boolean thisPath = false;
+
+ for (int i = 0, size = directories.size(); i < size; i++)
+ {
+ File d = directories.get(i), f = null;
+ if (pathRoot.equals(FileUtil.getCanonicalPath(d)))
+ {
+ thisPath = true;
+ }
+
+ try
+ {
+ f = findFile(d, relativePath, mimeTypes);
+ }
+ catch (CompilerException ex)
+ {
+ removeSource(s);
+ return false;
+ }
+
+ if (f != null && !thisPath)
+ {
+ removeSource(s);
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ protected Source findFile(String className, String namespaceURI, String localPart) throws CompilerException
+ {
+ String p = className.replace(':', '.').replace('.', File.separatorChar);
+ Source s = null;
+
+ for (int i = 0, size = directories.size(); i < size; i++)
+ {
+ File f, d = directories.get(i);
+
+ if ((f = findFile(d, p, mimeTypes)) != null)
+ {
+ sources.put(className, s = newSource(f, d, namespaceURI, localPart));
+ return s;
+ }
+ }
+
+ return null;
+ }
+
+ public boolean hasPackage(String packageName)
+ {
+ for (int i = 0, size = directories.size(); i < size; i++)
+ {
+ File d = directories.get(i);
+ if (hasDirectory(d, packageName))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public boolean hasDefinition(QName qName)
+ {
+ String className = CompilerAPI.constructClassName(qName.getNamespace(), qName.getLocalPart());
+
+ if (misses.contains(className))
+ {
+ return false;
+ }
+
+ if (hits.contains(className))
+ {
+ return true;
+ }
+
+ String p = className.replace(':', '.').replace('.', File.separatorChar);
+
+ for (int i = 0, size = directories.size(); i < size; i++)
+ {
+ File f, d = directories.get(i);
+
+ try
+ {
+ if ((f = findFile(d, p, mimeTypes)) != null)
+ {
+ hits.add(className);
+ return true;
+ }
+ }
+ catch (CompilerException ex)
+ {
+ }
+ }
+
+ misses.add(className);
+ return false;
+ }
+
+ private boolean hasDirectory(File dir, String packageName)
+ {
+ if (packageName.length() == 0)
+ {
+ return true;
+ }
+
+ String relativePath = packageName.replace('.', File.separatorChar);
+ String fullPath = dir.getPath() + File.separator + relativePath;
+
+ if (dirs.get(fullPath) == NO_DIR)
+ {
+ return false;
+ }
+
+ boolean result = new File(dir, relativePath).isDirectory();
+ dirs.put(fullPath, result ? fullPath : NO_DIR);
+
+ return result;
+ }
+
+ public List<File> getPaths()
+ {
+ return directories;
+ }
+ */
+ /**
+ * Resolves paths with a leading slash and relative to a Source
+ * Path directory.
+ */
+ public VirtualFile resolve(String path)
+ {
+ if (path.charAt(0) == '/')
+ {
+ String relativePath = path.substring(1);
+
+ for (File directory : directories)
+ {
+ File file = FileUtil.openFile(directory, relativePath);
+
+ if ((file != null) && file.exists())
+ {
+ return new LocalFile(file);
+ }
+ }
+ }
+
+ return null;
+ }
+
+ /*
+ public void setApplicationCache(ApplicationCache applicationCache)
+ {
+ this.applicationCache = applicationCache;
+ }
+ */
+}
+
+/**
+ * @author Clement Wong
+ */
+abstract class SourcePathBase
+{
+ protected final static String NO_DIR = "";
+
+ static void addApplicationParentToSourcePath(VirtualFile appPath, VirtualFile[] classPath, List<File> directories)
+ {
+ if (appPath != null)
+ {
+ File f = FileUtil.openFile(appPath.getParent());
+ // if (f != null && f.isDirectory())
+ if (f != null && f.isDirectory() && (FileUtil.isSubdirectoryOf(appPath.getParent(), classPath) == -1))
+ {
+ directories.add(f);
+ }
+ }
+ }
+
+ static void addPathElements(VirtualFile[] classPath, List<File> directories, boolean allowSourcePathOverlap, List<ClasspathOverlap> warnings)
+ {
+ boolean badPaths = false;
+
+ for (int i = 0, length = (classPath == null) ? 0 : classPath.length; i < length; i++)
+ {
+ String path = classPath[i].getName();
+ File f = FileUtil.openFile(path);
+ if (f != null && f.isDirectory())
+ {
+ if (!allowSourcePathOverlap && !badPaths)
+ {
+ int index = FileUtil.isSubdirectoryOf(f, directories);
+ if (index != -1)
+ {
+ String dirPath = directories.get(index).getAbsolutePath();
+ if (checkValidPackageName(path, dirPath))
+ {
+ // C: don't want to use ThreadLocalToolkit here...
+
+ // preilly: don't use logError below, because we don't stop
+ // compiling and if the error count is non-zero downstream mayhem
+ // occurs. For example, no SWC's get loaded, which makes it
+ // alittle tough to compile.
+
+ warnings.add(new ClasspathOverlap(path, dirPath));
+ badPaths = true;
+ }
+ }
+ }
+ directories.add(f);
+ }
+ }
+ }
+
+ private static boolean checkValidPackageName(String path1, String path2)
+ {
+ if (path1.equals(path2)) return true;
+ String packagePath = path1.length() > path2.length() ? path1.substring(path2.length()) : path2.substring(path1.length());
+
+ for (StringTokenizer t = new StringTokenizer(packagePath, File.separator); t.hasMoreTokens(); )
+ {
+ String s = t.nextToken();
+ if (!flex2.compiler.mxml.lang.TextParser.isValidIdentifier(s))
+ {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ public SourcePathBase(String[] mimeTypes, boolean allowSourcePathOverlap)
+ {
+ this.mimeTypes = mimeTypes;
+ this.allowSourcePathOverlap = allowSourcePathOverlap;
+ sources = new HashMap<String, Source>();
+
+ hits = new HashSet<String>();
+ misses = new HashSet<String>(1024);
+ dirs = new HashMap<String, String>();
+ warnings = new ArrayList<ClasspathOverlap>(5);
+ }
+
+ protected final String[] mimeTypes;
+ protected final Map<String, Source> sources;
+ protected boolean allowSourcePathOverlap;
+
+ protected final Set<String> hits, misses;
+ protected final HashMap<String, String> dirs;
+ protected final List<ClasspathOverlap> warnings;
+
+ /*
+ public Source findSource(String namespaceURI, String localPart) throws CompilerException
+ {
+ assert localPart.indexOf('.') == -1 && localPart.indexOf('/') == -1 && localPart.indexOf(':') == -1
+ : "findSource(" + namespaceURI + "," + localPart + ") has bad localPart";
+
+ // classname format is a.b:c
+ String className = CompilerAPI.constructClassName(namespaceURI, localPart);
+
+ return findSource(className, namespaceURI, localPart);
+ }
+
+ protected Source findSource(String className, String namespaceURI, String localPart) throws CompilerException
+ {
+ if (misses.contains(className))
+ {
+ return null;
+ }
+
+ Source s = sources.get(className);
+
+ if (s == null)
+ {
+ if ((s = findFile(className, namespaceURI, localPart)) != null)
+ {
+ return s;
+ }
+ }
+
+ CompilationUnit u = (s != null) ? s.getCompilationUnit() : null;
+
+ if (s != null && !s.exists())
+ {
+ sources.remove(className);
+ s = null;
+ }
+
+ if (adjustDefinitionName(namespaceURI, localPart, s, u))
+ {
+ u = null;
+ s = null;
+ }
+
+ if (s != null && ((u != null && !u.isDone()) || s.isUpdated()))
+ {
+ // s.removeCompilationUnit();
+ }
+ else if (s != null && u != null)
+ {
+ s = s.copy();
+ assert s != null;
+ }
+
+ if (s == null)
+ {
+ misses.add(className);
+ }
+
+ return s;
+ }
+
+ protected boolean adjustDefinitionName(String namespaceURI, String localPart, Source s, CompilationUnit u)
+ {
+ // If the compilation unit does exist and the top level definition name doesn't match
+ // the specified class name, we don't count it as a match.
+ if (s != null && u != null && u.topLevelDefinitions.size() == 1)
+ {
+ if (!u.topLevelDefinitions.contains(namespaceURI, localPart))
+ {
+ String realName = (u.topLevelDefinitions.first()).toString();
+ sources.put(realName, s);
+ misses.remove(realName);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ abstract boolean checkPreference(Source s);
+
+ protected abstract Source findFile(String className, String namespaceURI, String localPart) throws CompilerException;
+
+ protected File findFile(File directory, String relativePath, String[] mimeTypes) throws CompilerException
+ {
+ File found = null;
+
+ for (int k = 0, length = mimeTypes.length; k < length; k++)
+ {
+ File f = findFile(directory, relativePath, mimeTypes[k]);
+
+ if (f != null && found == null)
+ {
+ found = f;
+ // break;
+ }
+ else if (f != null)
+ {
+ throw new MoreThanOneComponentOfTheSameName(found.getAbsolutePath(), f.getAbsolutePath());
+ }
+ }
+
+ return found;
+ }
+
+ protected File findFile(File directory, String relativePath, String mimeType)
+ {
+ String fullPath = directory.getPath() + File.separator + relativePath;
+ int lastSlash = fullPath.lastIndexOf(File.separator);
+ String dir = null;
+ if (lastSlash != -1)
+ {
+ dir = fullPath.substring(0, lastSlash);
+ if (dirs.get(dir) == NO_DIR)
+ {
+ return null;
+ }
+ }
+
+ String path = relativePath + MimeMappings.getExtension(mimeType);
+ File f = FileUtil.openFile(directory, path);
+
+ if ((f != null) && f.isFile() && FileUtil.getCanonicalPath(f).endsWith(path))
+ {
+ return f;
+ }
+ else if (f != null && dir != null && !dirs.containsKey(dir))
+ {
+ File p = f.getParentFile();
+ dirs.put(dir, p != null && p.isDirectory() ? dir : NO_DIR);
+ }
+
+ return null;
+ }
+
+ String[] checkClassNameFileName(Source s)
+ {
+ String defName = null, pathName = null;
+
+ if (s.getOwner() == this)
+ {
+ QName def = s.getCompilationUnit().topLevelDefinitions.last();
+
+ defName = def.getLocalPart();
+ pathName = s.getShortName();
+
+ if (defName.equals(pathName))
+ {
+ return null;
+ }
+ }
+
+ return new String[] { pathName, defName };
+ }
+
+ String[] checkPackageNameDirectoryName(Source s)
+ {
+ String defPackage = null, pathPackage = null;
+
+ if (s.getOwner() == this)
+ {
+ QName def = s.getCompilationUnit().topLevelDefinitions.last();
+
+ defPackage = NameFormatter.normalizePackageName(def.getNamespace());
+ pathPackage = NameFormatter.toDot(s.getRelativePath(), '/');
+
+ if (defPackage.equals(pathPackage))
+ {
+ return null;
+ }
+ }
+
+ return new String[] { pathPackage, defPackage };
+ }
+
+ protected String constructRelativePath(Source s)
+ {
+ // + 1 removes the leading /
+ String relativePath = s.getName().substring(s.getPathRoot().getName().length() + 1);
+ for (int k = 0, length = mimeTypes.length; k < length; k++)
+ {
+ String ext = MimeMappings.getExtension(mimeTypes[k]);
+ if (relativePath.endsWith(ext))
+ {
+ relativePath = relativePath.substring(0, relativePath.length() - ext.length());
+ return relativePath;
+ }
+ }
+
+ assert false;
+ return null;
+ }
+
+ // used by CompilerAPI.validateCompilationUnits()... not efficient, but we rarely call it...
+ public void removeSource(Source s)
+ {
+ for (Iterator i = sources.entrySet().iterator(); i.hasNext(); )
+ {
+ Map.Entry e = (Map.Entry) i.next();
+ if (e.getValue() == s)
+ {
+ i.remove();
+ return;
+ }
+ }
+
+ assert false : "couldn't find " + s;
+ }
+
+ public void clearCache()
+ {
+ hits.clear();
+ misses.clear();
+ dirs.clear();
+ }
+
+ String[] getMimeTypes()
+ {
+ return mimeTypes;
+ }
+
+ public Map<String, Source> sources()
+ {
+ return sources;
+ }
+
+ public String toString()
+ {
+ StringBuilder buffer = new StringBuilder("SourcePath: \n");
+ Iterator<Source> iterator = sources.values().iterator();
+
+ while (iterator.hasNext())
+ {
+ Source source = iterator.next();
+ buffer.append("\tsource = " + source + ", cu = " + source.getCompilationUnit() + "\n");
+ }
+
+ return buffer.toString();
+ }
+
+ public void displayWarnings()
+ {
+ for (int i = 0, size = warnings.size(); i < size; i++)
+ {
+ ThreadLocalToolkit.log(warnings.get(i));
+ }
+ }
+ */
+
+ // error messages
+
+ public static class ClasspathOverlap extends CompilerMessage.CompilerWarning
+ {
+ private static final long serialVersionUID = -6314431057641028497L;
+
+ public ClasspathOverlap(String path, String directory)
+ {
+ super();
+ this.cpath = path;
+ this.directory = directory;
+ }
+
+ public final String cpath, directory;
+ }
+
+ public static class MoreThanOneComponentOfTheSameName extends CompilerMessage.CompilerInfo
+ {
+ private static final long serialVersionUID = 5943423934006966281L;
+
+ public MoreThanOneComponentOfTheSameName(String file1, String file2)
+ {
+ super();
+ this.file1 = file1;
+ this.file2 = file2;
+ }
+
+ public final String file1, file2;
+ }
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/SymbolTable.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/SymbolTable.java b/flex-compiler-oem/src/flex2/compiler/SymbolTable.java
new file mode 100644
index 0000000..a0f330e
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/SymbolTable.java
@@ -0,0 +1,60 @@
+/*
+ *
+ * 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.compiler;
+
+/**
+ * This class supports looking up information for a class or a style
+ * and looking up a <code>Source</code> by QName or by resource bundle
+ * name.
+ *
+ * @author Clement Wong
+ */
+public final class SymbolTable
+{
+ // These may look funny, but they line up with the values that ASC uses.
+ public static final String internalNamespace = "internal";
+ public static final String privateNamespace = "private";
+ public static final String protectedNamespace = "protected";
+ public static final String publicNamespace = "";
+ public static final String unnamedPackage = "";
+ public static final String[] VISIBILITY_NAMESPACES = new String[] {SymbolTable.publicNamespace,
+ SymbolTable.protectedNamespace,
+ SymbolTable.internalNamespace,
+ SymbolTable.privateNamespace};
+
+ public static final String NOTYPE = "*";
+ public static final String STRING = "String";
+ public static final String BOOLEAN = "Boolean";
+ public static final String NUMBER = "Number";
+ public static final String INT = "int";
+ public static final String UINT = "uint";
+ public static final String NAMESPACE = "Namespace";
+ public static final String FUNCTION = "Function";
+ public static final String CLASS = "Class";
+ public static final String ARRAY = "Array";
+ public static final String OBJECT = "Object";
+ public static final String XML = "XML";
+ public static final String XML_LIST = "XMLList";
+ public static final String REPARENT = "Reparent";
+ public static final String REGEXP = "RegExp";
+ public static final String EVENT = "flash.events:Event";
+ public static final String VECTOR = "__AS3__.vec:Vector";
+
+}
http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/dff3a518/flex-compiler-oem/src/flex2/compiler/as3/As3Configuration.java
----------------------------------------------------------------------
diff --git a/flex-compiler-oem/src/flex2/compiler/as3/As3Configuration.java b/flex-compiler-oem/src/flex2/compiler/as3/As3Configuration.java
new file mode 100644
index 0000000..eddad63
--- /dev/null
+++ b/flex-compiler-oem/src/flex2/compiler/as3/As3Configuration.java
@@ -0,0 +1,166 @@
+/*
+ *
+ * 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.compiler.as3;
+
+import macromedia.asc.embedding.ConfigVar;
+import macromedia.asc.util.ObjectList;
+
+/**
+ * This interface is used to restrict consumers of
+ * CompilerConfiguration to as3 compiler specific options.
+ *
+ * @author Clement Wong
+ * @see flex2.compiler.common.CompilerConfiguration
+ */
+public interface As3Configuration
+{
+ /**
+ * Omit method arg names.
+ */
+ boolean optimize();
+
+ /**
+ * Emit system paths with debug info.
+ */
+ boolean verboseStacktraces();
+
+ /**
+ * Generate SWFs for debugging
+ */
+ boolean debug();
+
+ int dialect();
+ boolean adjustOpDebugLine();
+
+ /**
+ * Run the AS3 compiler in strict mode
+ */
+ boolean strict();
+
+ /**
+ * Enable asc -warnings
+ */
+ boolean warnings();
+
+ /**
+ * Generate asdoc
+ */
+ boolean doc();
+
+ /**
+ * user-defined AS3 file encoding
+ */
+ String getEncoding();
+
+ /**
+ * Configuration settings (ConfigVars) from <code>--compiler.define</code>
+ * are retrieved using this getter.
+ *
+ * @return ObjectList<macromedia.asc.embedding.ConfigVar>
+ */
+ ObjectList<ConfigVar> getDefine();
+
+ boolean getGenerateAbstractSyntaxTree();
+
+ /**
+ * Whether to export metadata into ABCs
+ */
+ public boolean metadataExport();
+
+ public boolean showDeprecationWarnings();
+
+ // coach warnings
+
+ public boolean warn_array_tostring_changes();
+
+ public boolean warn_assignment_within_conditional();
+
+ public boolean warn_bad_array_cast();
+
+ public boolean warn_bad_bool_assignment();
+
+ public boolean warn_bad_date_cast();
+
+ public boolean warn_bad_es3_type_method();
+
+ public boolean warn_bad_es3_type_prop();
+
+ public boolean warn_bad_nan_comparison();
+
+ public boolean warn_bad_null_assignment();
+
+ public boolean warn_bad_null_comparison();
+
+ public boolean warn_bad_undefined_comparison();
+
+ public boolean warn_boolean_constructor_with_no_args();
+
+ public boolean warn_changes_in_resolve();
+
+ public boolean warn_class_is_sealed();
+
+ public boolean warn_const_not_initialized();
+
+ public boolean warn_constructor_returns_value();
+
+ public boolean warn_deprecated_event_handler_error();
+
+ public boolean warn_deprecated_function_error();
+
+ public boolean warn_deprecated_property_error();
+
+ public boolean warn_duplicate_argument_names();
+
+ public boolean warn_duplicate_variable_def();
+
+ public boolean warn_for_var_in_changes();
+
+ public boolean warn_import_hides_class();
+
+ public boolean warn_instance_of_changes();
+
+ public boolean warn_internal_error();
+
+ public boolean warn_level_not_supported();
+
+ public boolean warn_missing_namespace_decl();
+
+ public boolean warn_negative_uint_literal();
+
+ public boolean warn_no_constructor();
+
+ public boolean warn_no_explicit_super_call_in_constructor();
+
+ public boolean warn_no_type_decl();
+
+ public boolean warn_number_from_string_changes();
+
+ public boolean warn_scoping_change_in_this();
+
+ public boolean warn_slow_text_field_addition();
+
+ public boolean warn_unlikely_function_value();
+
+ public boolean warn_xml_class_has_changed();
+
+ public boolean keepEmbedMetadata();
+
+ public boolean getAdvancedTelemetry();
+}