*

*  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.

*

*/

* The tasks of the InterfaceCompiler are:

*

* <p>1. Expose the public signature of our generated MXML class at the same point in the compiler workflow as a native

* AS class would. This means generating "public signature" AS code <strong>immediately</strong> (i.e., for consumption

* in analyze1..N). This public signature must contain:

*

*  <br>-typed declarations for any MXML children with id attributes;

*  <br>-user script code (which might also contain public declarations).

*

* <p>2. "Bring in" all types referred to by component tags, so that MXML DOM traversal, which happens in the

* ImplementationCompiler, has the information it needs to disambiguate child tags.

*

* <p>Example: if a &lt;Button/&gt; tag appears in the document, information contained in the definition for

* mx.controls.Button (assuming that's what &lt;Button/&gt; resolves to) will be necessary for disambiguating properties,

* styles, nested components, etc., in the associated MXML subtree.

*

* <p>The InterfaceCompiler's postprocess() phase uses (local class) DependencyAnalyzer to do this type registration.

*

* <p><strong>Note that not all necessary imports are registered here, only types needed to process the MXML DOM.</strong>

* For instance, the definitions specified by name for Class- and Function-typed properties and styles need to be imported,

* but they are not necessary for DOM processing. They're registered as imports later, <strong>during</strong> DOM

* processing, as the properties etc. are actually processed (see e.g. AbstractBuilder.TextParser's className() handler).

*

* <p>Why not register all such types here? Because values are subject to interpretation (e.g. @Embeds, or

* {bindings}, may appear as rvalues, and have different type implications), and all that sort of interpretation happens

* during DOM processing (by the Builders). Ordinary type registration happens naturally at that point; think of the

* registration that happens here as being "early" out of necessity, but as minimal as possible.

* <p>2a. update: the blanket early-class-import requirement due to style trimming has been removed. However, there are

* still early-import dependencies in the Builders (other than for DOM-walking), including some that may be unnecessary.

* One that definitely *is* and will remain necessary is due to generating classname-to-IFactory coercions: the AbstractBuilder

* code introspects the definition associated with the classname in order to generate automatic assignments of properties

* like outerDocument. Others may be brunable, including event type defs and generic imports of the classes assigned to

* Class-typed properties. TODO: review and narrow the set of import requests generated here to only those that are

* strictly necessary.

*

* <p>At the end of the InterfaceCompiler phases, the workflow switches to ImplementationCompiler for generation of the

* complete AS code. (As noted above, the additional dependencies outside those needed purely for the document's

* component tags, are detected and registered during that phase.)

*

* @author Clement Wong

*

* Changed to extend AbstractSubCompiler to clean up benchmarking code and enble

* embedded compiler benchmarking - bfrazer

*

* Changed class to public so that it can be used directly for mxml parsing by other tools. - gauravj

*/

// e.g. [Event]. This will require sneaking code generation into the

// beginning of analyze1().

    //  path to our velocity template

    private static final String TemplatePath = InterfaceCompiler.class.getPackage().getName().replace('.', '/') + "/gen/";

    //  context attributes

    private static final String AttrTypeRequests = "TypeRequests";

    private static final String AttrInlineComponentSyntaxTree = "InlineComponentSyntaxTree";

    private static final String DOCUMENT_NODE = "DocumentNode";

  private static final String EMPTY_STRING = "";

  private boolean processComments = false;

 

  /**

   *

   */

  public InterfaceCompiler(final MxmlConfiguration mxmlConfiguration,

               final As3Configuration ascConfiguration,

               NameMappings mappings, boolean processComments)

  {

    this.mxmlConfiguration = mxmlConfiguration;

    this.ascConfiguration = ascConfiguration;

    this.nameMappings = mappings;

    this.processComments = processComments;

   

    mimeTypes = new String[]{MimeMappings.MXML};

    asc = new As3Compiler(new As3Configuration()

    {

            public boolean optimize() { return true; }

            public boolean verboseStacktraces() { return false; }

            public boolean debug() { return false; }

            public boolean strict() { return ascConfiguration.strict(); }

            public int dialect() { return ascConfiguration.dialect(); }

            public boolean adjustOpDebugLine() { return ascConfiguration.adjustOpDebugLine(); }

            public boolean warnings() { return false; }

            public boolean doc() { return false; }

            public boolean getGenerateAbstractSyntaxTree() { return ascConfiguration.getGenerateAbstractSyntaxTree(); }

            public String getEncoding() { return null; }

            public boolean metadataExport() { return false; }

            public boolean showDeprecationWarnings() { return false; }

            public boolean warn_array_tostring_changes() { return false; }

            public boolean warn_assignment_within_conditional() { return false; }

            public boolean warn_bad_array_cast() { return false; }

            public boolean warn_bad_bool_assignment() { return false; }

            public boolean warn_bad_date_cast() { return false; }

            public boolean warn_bad_es3_type_method() { return false; }

            public boolean warn_bad_es3_type_prop() { return false; }

            public boolean warn_bad_nan_comparison() { return false; }

            public boolean warn_bad_null_assignment() { return false; }

            public boolean warn_bad_null_comparison() { return false; }

            public boolean warn_bad_undefined_comparison() { return false; }

            public boolean warn_boolean_constructor_with_no_args() { return false; }

            public boolean warn_changes_in_resolve() { return false; }

            public boolean warn_class_is_sealed() { return false; }

            public boolean warn_const_not_initialized() { return false; }

            public boolean warn_constructor_returns_value() { return false; }

            public boolean warn_deprecated_event_handler_error() { return false; }

            public boolean warn_deprecated_function_error() { return false; }

            public boolean warn_deprecated_property_error() { return false; }

            public boolean warn_duplicate_argument_names() { return false; }

            public boolean warn_duplicate_variable_def() { return false; }

            public boolean warn_for_var_in_changes() { return false; }

            public boolean warn_import_hides_class() { return false; }

            public boolean warn_instance_of_changes() { return false; }

            public boolean warn_internal_error() { return false; }

            public boolean warn_level_not_supported() { return false; }

            public boolean warn_missing_namespace_decl() { return false; }

            public boolean warn_negative_uint_literal() { return false; }

            public boolean warn_no_constructor() { return false; }

            public boolean warn_no_explicit_super_call_in_constructor() { return false; }

            public boolean warn_no_type_decl() { return false; }

            public boolean warn_number_from_string_changes() { return false; }

            public boolean warn_scoping_change_in_this() { return false; }

            public boolean warn_slow_text_field_addition() { return false; }

            public boolean warn_unlikely_function_value() { return false; }

            public boolean warn_xml_class_has_changed() { return false; }

      public ObjectList<ConfigVar> getDefine() { return ascConfiguration.getDefine(); }

            public boolean keepEmbedMetadata() { return false; }

        });

        asc.addCompilerExtension(new HostComponentExtension(mxmlConfiguration.reportMissingRequiredSkinPartsAsWarnings()));

    }

  private As3Configuration ascConfiguration;

  private MxmlConfiguration mxmlConfiguration;

  private NameMappings nameMappings;

  private String[] mimeTypes;

  private As3Compiler asc;

  As3Compiler getASCompiler()

    {

        return asc;

    }

   

    public boolean isSupported(String mimeType)

    {

        for (int i = 0; i < mimeTypes.length; i++)

        {

            if (mimeTypes[i].equals(mimeType))

                    return true;

        }

        return false;

    }

    public String[] getSupportedMimeTypes()

    {

        return mimeTypes;

    }

    public Source preprocess(Source source)

    {

    String componentName = source.getShortName();

        if (!TextParser.isValidIdentifier(componentName))

        {

            CompilerMessage m = new InvalidComponentName(componentName);

            m.setPath(source.getNameForReporting());

            ThreadLocalToolkit.log(m);

        }

        return source;

    }

    /**

     * Do basic MXML parse, generate AS containing public signature contributors, and parse that using our ASC instance.

     * Result will be "outer" compilation unit, with the unit returned by ASC stashed in a context attribute.

     */

    public CompilationUnit parse1(Source source, SymbolTable symbolTable)

    {

    CompilerContext context = new CompilerContext();

        // 1. parse/analyze MXML, or retrieve preparsed DOM

        // 2. add MXML syntax tree to a new CompilationUnit

        DocumentNode app;

        CompilationUnit unit;

        Object preparsedSyntaxTree = source.getSourceFragment(AttrInlineComponentSyntaxTree);

        if (preparsedSyntaxTree == null)

        {

            app = parseMXML(source);

            if (app == null)

            {

                return null;

            }

            unit = source.newCompilationUnit(app, context);

            // do more syntax checking, chase includes, etc.

            app.analyze(new SyntaxAnalyzer(unit, mxmlConfiguration));

            if (ThreadLocalToolkit.errorCount() > 0)

            {

                return null;

            }

        }

        else

        {

            assert preparsedSyntaxTree instanceof DocumentNode : "bogus preparsed root node passed to InterfaceCompiler";

            app = (DocumentNode) preparsedSyntaxTree;

            unit = source.newCompilationUnit(app, context);

        }

        unit.getContext().setAttribute(DOCUMENT_NODE, app);

        //  start a new DocumentInfo. this will accumulate document state as compilation proceeds

        DocumentInfo docInfo = createDocumentInfo(unit, app, source);

        if (ThreadLocalToolkit.errorCount() > 0)

        {

            return null;

        }

        unit.getContext().setAttribute(MxmlCompiler.DOCUMENT_INFO, docInfo);

        unit.topLevelDefinitions.add(new QName(docInfo.getPackageName(), docInfo.getClassName()));

        transferDependencies(docInfo, unit.inheritance, unit.inheritanceHistory);

        return unit;

    }

   

    public void parse2(CompilationUnit unit, SymbolTable symbolTable)

    {

    DocumentInfo docInfo = (DocumentInfo) unit.getContext().getAttribute(MxmlCompiler.DOCUMENT_INFO);

        Source source = unit.getSource();

        //  get parsed superclass info - NOTE may be null in case of error

        ClassInfo baseClassInfo = getClassInfo(source, symbolTable, docInfo.getQualifiedSuperClassName());

        if (baseClassInfo == null && docInfo.getQualifiedSuperClassName() != null)

        {

            String qualifiedClassName = NameFormatter.toDot(docInfo.getPackageName(), docInfo.getClassName());

            ThreadLocalToolkit.log(new BaseClassNotFound(qualifiedClassName, docInfo.getQualifiedSuperClassName()), source);

            return;

        }

        //  InterfaceAnalyzer will collect items to be included in generated interface code, and add them to info

        InterfaceAnalyzer analyzer = new InterfaceAnalyzer(unit, docInfo, baseClassInfo, mxmlConfiguration.getGenerateAbstractSyntaxTree());

        DocumentNode app = (DocumentNode) unit.getContext().getAttribute(DOCUMENT_NODE);

        app.analyze(analyzer);

        if (ThreadLocalToolkit.errorCount() > 0)

        {

            return;

        }

    //  generate AS for the interface (i.e., public signature) of our class. This will include

    //  - superclass, interface and metadata declarations, as specified in the MXML

    //  - public var declarations for id-attributed children of the MXML

    //  - user-supplied script code

    LineNumberMap map = new LineNumberMap(source.getName());

    Source newSource;

    Logger original = ThreadLocalToolkit.getLogger();

    if (mxmlConfiguration.getGenerateAbstractSyntaxTree())

    {

      Logger adapter = new AbstractSyntaxTreeLogAdapter(original);

      ThreadLocalToolkit.setLogger(adapter);

      newSource = generateSkeletonAST(docInfo, analyzer.bogusImports, source, symbolTable);

    }

    else

    {

      MxmlLogAdapter adapter = new MxmlLogAdapter(original, map);

      adapter.addLineNumberMaps(unit.getSource().getSourceFragmentLineMaps());

      ThreadLocalToolkit.setLogger(adapter);

      newSource = generateSkeleton(docInfo, analyzer.bogusImports, map, source);

      if (newSource == null)

      {

        ThreadLocalToolkit.setLogger(original);

        return;

      }

      map.setNewName(newSource.getName());

    }

    //  use ASC to produce new CU for generated interface source. Will be managed by "outer" MXML CU

    CompilationUnit interfaceUnit = compileInterface(newSource, source, docInfo, map, symbolTable);

    if (interfaceUnit != null)

    {

      //  transfer includes from the interface unit to the real MXML unit

      unit.getSource().addFileIncludes(interfaceUnit.getSource());

            //  InterfaceUnit, LineNumberMap are used in subsequent phases of InterfaceCompiler

            unit.getContext().setAttribute(MxmlCompiler.LINE_NUMBER_MAP, map);

            unit.getContext().setAttribute(MxmlCompiler.DELEGATE_UNIT, interfaceUnit);

            Source.transferMetaData(interfaceUnit, unit);

            // Source.transferAssets(interfaceUnit, unit);

            // Source.transferGeneratedSources(interfaceUnit, unit);

        }

        else

        {

      ThreadLocalToolkit.setLogger(original);

            return;

        }

        Source.transferInheritance(unit, interfaceUnit);

        asc.parse2(interfaceUnit, symbolTable);

        ThreadLocalToolkit.setLogger(original);

    }

    /**

     * run asc.analyze1() on unit's private AS unit representing the public signature, shuttling results back to outer unit

     */

    public void analyze1(CompilationUnit unit, SymbolTable symbolTable)

    {

    CompilationUnit interfaceUnit = (CompilationUnit) unit.getContext().getAttribute(MxmlCompiler.DELEGATE_UNIT);

    Logger original = setLogAdapter(unit);

        asc.analyze1(interfaceUnit, symbolTable);

        ThreadLocalToolkit.setLogger(original);

        Source.transferTypeInfo(interfaceUnit, unit);

        Source.transferNamespaces(interfaceUnit, unit);

    }

    /**

     * run asc.analyze1() on unit's private AS unit representing the public signature, shuttling results back to outer unit

     */

    public void analyze2(CompilationUnit unit, SymbolTable symbolTable)

    {

    CompilationUnit interfaceUnit = (CompilationUnit) unit.getContext().getAttribute(MxmlCompiler.DELEGATE_UNIT);

        Source.transferDependencies(unit, interfaceUnit);

       

    Logger original = setLogAdapter(unit);

        asc.analyze2(interfaceUnit, symbolTable);

        ThreadLocalToolkit.setLogger(original);

        Source.transferDependencies(interfaceUnit, unit);

    }

    public void analyze3(CompilationUnit unit, SymbolTable symbolTable)

    {

    CompilationUnit interfaceUnit = (CompilationUnit) unit.getContext().getAttribute(MxmlCompiler.DELEGATE_UNIT);

        // C: unit.importDefinitionStatements has no bogus statements

        //    interfaceUnit.importDefinitionStatements may have bogus statements.

        QNameSet importDefinitionStatements = new QNameSet(interfaceUnit.importDefinitionStatements);

        Source.transferDependencies(unit, interfaceUnit);

        // C: But we tell asc that those bogus statements are legitimate.

        //    Don't try this in ImplementationCompiler!

        interfaceUnit.importDefinitionStatements.addAll(importDefinitionStatements);

    Logger original = setLogAdapter(unit);

        asc.analyze3(interfaceUnit, symbolTable);

        ThreadLocalToolkit.setLogger(original);

    }

    /**

     * run asc.analyze1() on unit's private AS unit representing the public signature, shuttling results back to outer unit

     */

    public void analyze4(CompilationUnit unit, SymbolTable symbolTable)

    {

    CompilationUnit interfaceUnit = (CompilationUnit) unit.getContext().getAttribute(MxmlCompiler.DELEGATE_UNIT);

    Logger original = setLogAdapter(unit);

        asc.analyze4(interfaceUnit, symbolTable);

        ThreadLocalToolkit.setLogger(original);

        for( Map.Entry<String, AbcClass> entry : interfaceUnit.classTable.entrySet() )

        {

            // Freeeze the clases generated for the interface file, so that we

            // can still access them when we are building the generated file.

            //System.out.println("Freezing " + entry.getKey());

            AbcClass c = entry.getValue();

            c.freeze();

        }

        Source.transferDependencies(interfaceUnit, unit);

        Source.transferLoaderClassBase(interfaceUnit, unit);

        Source.transferGeneratedSources(interfaceUnit, unit);

        Source.transferClassTable(interfaceUnit, unit);

        Source.transferStyles(interfaceUnit, unit);

    }

    public void generate(CompilationUnit unit, SymbolTable symbolTable)

    {

        // Source.transferBytecodes(interfaceUnit, unit);

    }

    /**

     * Perform stepwise breadth-first traversal of MXML DOM to generate dependency information. At each step, the set

     * <code>checkNodes</code> contains nodes that are known to represent component (not property) tags, for which the

     * backing classdefs are known to be available in <code>symbolTable</code>.

     * <p>

     * On each such node N, we run the DependencyAnalyzer to collect the set of N's child

     * component (not property) nodes. These are added to the new <code>checkNodes</code>, and names of their backing

     * classes are added to the compilation unit's dependencies. As a result of the latter, the classdefs should be

     * present in symbolTable by the next time postprocess() is called.

     * <p>

     * The DependencyAnalyzer will also accumulate information into DocumentInfo for later use, as a side effect of this

     * traversal.

     */

  public void postprocess(CompilationUnit unit, SymbolTable symbolTable)

    {

        TypeTable typeTable = (TypeTable) symbolTable.getContext().getAttribute(MxmlCompiler.TYPE_TABLE);

        if (typeTable == null)

        {

            typeTable = new TypeTable(symbolTable, nameMappings, unit.getStandardDefs(),

                                      mxmlConfiguration.getThemeNames());

            symbolTable.getContext().setAttribute(MxmlCompiler.TYPE_TABLE, typeTable);

        }

        DocumentInfo info = (DocumentInfo)unit.getContext().getAttribute(MxmlCompiler.DOCUMENT_INFO);

        @SuppressWarnings("unchecked")

        Set<Node> checkNodes = (Set<Node>)unit.getContext().getAttribute(MxmlCompiler.CHECK_NODES);

       

        @SuppressWarnings("unchecked")

        Set<MultiName> allTypeRequests = (Set<MultiName>)unit.getContext().getAttribute(AttrTypeRequests);

        if (checkNodes == null)

        {

            //  first call to postprocess

            //  seed checkNodes with root node

            checkNodes = new HashSet<Node>();

            checkNodes.add(info.getRootNode());

            //  set up type request record - apparently unit.expressions gets scrubbed of multinames that fail to resolve?

            allTypeRequests = new HashSet<MultiName>();

            unit.getContext().setAttribute(AttrTypeRequests, allTypeRequests);

        }

        if (!checkNodes.isEmpty())

        {

            Set<Node> newCheckNodes = new HashSet<Node>();

            Set<MultiName> newTypeRequests = new HashSet<MultiName>();

            DependencyAnalyzer analyzer = new DependencyAnalyzer(unit, typeTable, info, newCheckNodes, newTypeRequests, allTypeRequests);

            for (Iterator<Node> i = checkNodes.iterator(); i.hasNext(); )

            {

                i.next().analyze(analyzer);

            }

            unit.getContext().setAttribute(MxmlCompiler.CHECK_NODES, newCheckNodes);

            if (!newTypeRequests.isEmpty())

            {

                //  add new type requests to our memory list

                allTypeRequests.addAll(newTypeRequests);

                for (MultiName newTypeRequest : newTypeRequests)

                {

                    unit.expressions.add(newTypeRequest);

                }

            }

        }

    }

    private void transferDependencies(DocumentInfo docInfo, Set<Name> target, MultiNameMap history)

    {

        target.add(NameFormatter.toMultiName(docInfo.getQualifiedSuperClassName()));

        Iterator iterator = docInfo.getInterfaceNames().iterator();

        while (iterator.hasNext())

        {

            NameInfo nameInfo = (NameInfo) iterator.next();

            target.add(NameFormatter.toMultiName(nameInfo.getName()));

        }

    }

    /**

     * parse MXML source into an DocumentNode

     */

  // Changed method to public so that it can be used directly for mxml parsing by other tools (code coverage). - gauravj

  public DocumentNode parseMXML(Source source)

    {

        DocumentNode app = null;

        InputStream in = null;

        try

        {

            in = new BufferedInputStream(source.getInputStream());

            flex2.compiler.mxml.dom.MxmlScanner s = new flex2.compiler.mxml.dom.MxmlScanner(in, mxmlConfiguration.enableRuntimeDesignLayers(), processComments );

            Parser p = new Parser(s);

            MxmlVisitor v = new SyntaxTreeBuilder();

            p.setVisitor(v);

            app = (DocumentNode) p.parseApplication();

            //  check for MXML 1 namespace - check code is here only so it doesn't run on every node.

            //  NOTE: of course, you can place this namespace on *any* node, and use it as a legitimate manifest key.

            //  This error does a special check in the interests of detecting an obvious mistake early.

            if (!checkMxmlNamespace(source, app))

            {

                app = null;

            }

        }

        catch (ParseException ex)

        {

            Token token = ex.currentToken.next;

            //  Strip the unhelpful "was expecting ..." part of JavaCC exception message.

            String msg = ex.getMessage();

            int wasExpecting = msg.indexOf(System.getProperty("line.separator") + "Was expecting");

            if (wasExpecting > 0)

            {

                msg = msg.substring(0, wasExpecting);

                //  experience tells us that msg is now "Encountered \"...\" at line X, column Y."

                //  Here we just want to reverse-engineer this so it can be localized, but we also fault to

                //  printing the unlocalized message if it's not the pattern above.

                //  Also note that we don't need to get the line/column info from the message; it's in token.

                Pattern msgPatt = Pattern.compile("Encountered \"(.*)\" at line.*");

                Matcher m = msgPatt.matcher(msg);

                if (m.matches())

                {

                    //  convert to localized version

                    String parent = ex.currentToken.image;

                    String child = ex.currentToken.next.image;

                    msg = new InvalidToken(parent, child).getLocalizedMessage();

                }

            }

            ThreadLocalToolkit.logError(source.getNameForReporting(), token.beginLine, token.beginColumn, msg);

            app = null;

        }

        catch (Exception ex) // FileNotFoundException, IOException

        {

            String msg = ex.getMessage();

            if (msg == null)

            {

                StringWriter stwriter = new StringWriter();

                PrintWriter pw = new PrintWriter(stwriter);

                ex.printStackTrace(pw);

                msg = stwriter.toString();

            }

            ThreadLocalToolkit.logError(source.getNameForReporting(), msg);

            app = null;

        }

        catch (ScannerError err)

        {

            String msg = err.getReason();

            // We want a different error message here, so we check for the one that we'd like to change.

            // The message is always in English.

            if (msg.equals(flex2.compiler.mxml.dom.MxmlScanner.MarkupNotRecognizedInContent))

            {

                InvalidCharacterOrMarkup e = new InvalidCharacterOrMarkup();

                e.setLine(err.getLineNumber());

                e.setColumn(err.getColumnNumber());

                ThreadLocalToolkit.log(e, source);

            }

            else if (msg.equals(flex2.compiler.mxml.dom.MxmlScanner.ReservedPITarget))

            {

                WhitespaceBeforePI e = new WhitespaceBeforePI();

                e.setLine(err.getLineNumber());

                e.setColumn(err.getColumnNumber());

                ThreadLocalToolkit.log(e, source);

            }

            else if (msg.equals(flex2.compiler.mxml.dom.MxmlScanner.MarkupNotRecognizedInMisc))

            {

                InvalidMarkupAfterRootElement e = new InvalidMarkupAfterRootElement();

                e.setLine(err.getLineNumber());

                e.setColumn(err.getColumnNumber());

                ThreadLocalToolkit.log(e, source);

            }

            else

            {

                //  regexp-based msg traps for localization

                Pattern msgPatt;

                Matcher m;

                // C: I'm not sure if the pattern matcher supports double-byte characters. Let's leave

                //    this one alone for now...

               

                //  1. The element type "..." must be terminated by the matching end-tag "</...>"

                msgPatt = Pattern.compile("The element type \"(.*)\" must be terminated by the matching end-tag \"(.*)\".");

                m = msgPatt.matcher(msg);

                if (m.matches())

                {

                    msg = new MissingEndTag(m.group(1), m.group(2)).getLocalizedMessage();

                }

                //  additional traps would go here... unless we can localize Xerces, which would be better

                ThreadLocalToolkit.logError(source.getNameForReporting(), err.getLineNumber(), err.getColumnNumber(), msg);

            }

            app = null;

        }

        finally

        {

            if (in != null)

            {

                try

                {

                    in.close();

                }

                catch (IOException ex)

                {

                }

            }

        }

        return app;

    }

    /**

     *

     */

    private boolean checkMxmlNamespace(Source source, Node node)

    {

        if (node.getNamespace().equals(MXML_1_NAMESPACE) || node.getNamespace().equals(MXML_2_NAMESPACE))

        {

            ThreadLocalToolkit.log(new WrongMXMLNamespace(node.getNamespace(), MXML_2009_NAMESPACE), source);

            return false;

        }

        else

        {

            return true;

        }

    }

    /**

     * set up a DocumentInfo for the compilation:

     * <li>- initializes everything immediately derivable from root node and source properties

     * <li>- populates import names with initial set

     * <p>InterfaceAnalyzer then adds additional stuff from the DOM, prior to interface codegen

     */

    private DocumentInfo createDocumentInfo(CompilationUnit unit, DocumentNode app, Source source)

    {

        StandardDefs standardDefs = unit.getStandardDefs();

        DocumentInfo info = new DocumentInfo(source.getNameForReporting(), standardDefs);

        //  set MXML root

        info.setRootNode(app, app.beginLine);

       

        //  package/class is derived from source name and location

        info.setClassName(source.getShortName());

        info.setPackageName(source.getRelativePath().replace('/','.'));

        //  superclass is derived from root node name

        // first, check to see if the base class is a local class

        String superClassName = info.getLocalClass(app.getNamespace(), app.getLocalPart());

        // otherwise, check the usual manifest mappings

        if (superClassName == null)

            superClassName = nameMappings.resolveClassName(app.getNamespace(), app.getLocalPart());

        if (superClassName != null)

        {

            info.setQualifiedSuperClassName(NameFormatter.toDot(superClassName), app.beginLine);

        }

        else

        {

            ThreadLocalToolkit.log(new AnalyzerAdapter.CouldNotResolveToComponent(app.image), source, app.beginLine);

            return null;

        }

        //  interfaces specified by "implements" attribute.

        //  TODO "implements" is language def, it should be in a list of language constants somewhere

        String interfaceNames = (String) app.getAttributeValue("implements");

        if (interfaceNames != null)

        {

            StringTokenizer t = new StringTokenizer(interfaceNames, ",");

            while (t.hasMoreTokens())

            {

                info.addInterfaceName(t.nextToken().trim(), app.getLineNumber("implements"));

            }

        }

        //  seed import name set with the unconditional imports present in all generated MXML classes

        if (mxmlConfiguration.getGenerateAbstractSyntaxTree())

        {

            info.addSplitImportNames(StandardDefs.splitImplicitImports);

            // See SDK-16946

            if (info.getVersion() >= 4)

            {

                info.removeSplitImportName(NameFormatter.toDotStar(StandardDefs.PACKAGE_FLASH_FILTERS));

                info.addSplitImportName(NameFormatter.toDotStar(StandardDefs.PACKAGE_MX_FILTERS),

                                        StandardDefs.splitPackageMxFilters);

            }

            if (mxmlConfiguration.getCompilingForAIR())

            {

                info.addSplitImportNames(StandardDefs.splitAirOnlyImplicitImports);

            }

            info.addSplitImportNames(standardDefs.getSplitStandardMxmlImports());

        }

        else

        {

            info.addImportNames(StandardDefs.implicitImports, app.beginLine);

            // See SDK-16946

            if (info.getVersion() >= 4)

            {

                info.removeImportName(NameFormatter.toDotStar(StandardDefs.PACKAGE_FLASH_FILTERS));

                info.addImportName(NameFormatter.toDotStar(StandardDefs.PACKAGE_MX_FILTERS), app.beginLine);

            }

            if (mxmlConfiguration.getCompilingForAIR())

            {

                info.addImportNames(StandardDefs.airOnlyImplicitImports, app.beginLine);

            }

            info.addImportNames(standardDefs.getStandardMxmlImports(), app.beginLine);

        }

        return info;

    }

    /**

     *

     */

    private static ClassInfo getClassInfo(Source source, SymbolTable symbolTable, String className)

    {

        //  NOTE: make throwaway ASC context, since our real one isn't created until ASC parses the generated code.

        macromedia.asc.util.Context tempContext = new macromedia.asc.util.Context(symbolTable.perCompileData);

        tempContext.setScriptName(source.getName());

        tempContext.setPath(source.getParent());

        tempContext.setEmitter(symbolTable.emitter);

    tempContext.setHandler(new As3Compiler.CompilerHandler());

        symbolTable.perCompileData.handler = tempContext.getHandler();

        return symbolTable.getTypeAnalyzer().analyzeClass(tempContext, new MultiName(NameFormatter.toColon(className)));

    }

  /**

   * generate skeleton code based on information in DocumentInfo

   */

  private Source generateSkeleton(DocumentInfo info, Set<String> bogusImports, LineNumberMap map, Source source)

  {

    //long start = System.currentTimeMillis();

      String path = source.getName();

      StandardDefs standardDefs = info.getStandardDefs();

      String templateName = TemplatePath + standardDefs.getInterfaceDefTemplate();

    Template template = VelocityManager.getTemplate(templateName);

    if (template != null)

    {

      try

      {

        // create a velocity context

        VelocityContext velocityContext = VelocityManager.getCodeGenContext();

        //  SourceCodeBuffer tracks line number change during codegen

        SourceCodeBuffer out = new SourceCodeBuffer((int) source.size());

        //  create SourceCode wrappers for scripts

        Set<SourceCode> scriptSet = new LinkedHashSet<SourceCode>();

        for (Iterator iter = info.getScripts().iterator(); iter.hasNext(); )

        {

          Script script = (Script) iter.next();

          if (!script.isEmbedded())

          {

            scriptSet.add(new SourceCode(script.getText(), script.getXmlLineNumber(), out, map));

          }

          else

          {

            // use Source.getName() to construct the new VirtualFile name

            String n = source.getName().replace('\\', '/') + ":" + script.getXmlLineNumber() + "," + script.getEndXmlLineNumber();

            VirtualFile f = new TextFile(script.getText(), n, source.getParent(), MimeMappings.AS, source.getLastModified());

                        // line number map is for error reporting, so the names must come from error reporting...

                        LineNumberMap m = new LineNumberMap(source.getNameForReporting(), n);

                        m.put(script.getXmlLineNumber(), 1, (script.getEndXmlLineNumber() - script.getXmlLineNumber()));

                        // C: add this so that when unexpected EOF occurs, (last line + 1) maps to the last line

                        //    in the original XML Script block.

                        m.put(script.getEndXmlLineNumber(), script.getEndXmlLineNumber() - script.getXmlLineNumber() + 1, 1);

                        // 'n' must match 'n' in the include directive...

                        source.addSourceFragment(n, f, m);

                        // 'n' must match 'n' in the addSourceFragment call.

                        scriptSet.add(new SourceCode("include \"" + n + "\";", script.getXmlLineNumber(), out, map));

                    }

                }

                //  create SourceCode wrappers for metadata entries

                Set<SourceCode> metadataSet = new LinkedHashSet<SourceCode>();

                for (Iterator iter = info.getMetadata().iterator(); iter.hasNext(); )

                {

                    Script script = (Script)iter.next();

                    metadataSet.add(new SourceCode(script.getText(), script.getXmlLineNumber(), out, map));