root/org.axdt.as3/src/org/axdt/as3/imp/parser/AS3ParseController.java @ a106cc373e028ca3bb89023c7e8ee459713ff2c3

package org.axdt.as3.imp.parser;

import org.axdt.as3.AS3Plugin;
import org.axdt.as3.imp.parser.Ast.ASTNode;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.imp.services.ILanguageSyntaxProperties;
import org.eclipse.imp.model.ISourceProject;
import org.eclipse.imp.parser.ILexer;
import org.eclipse.imp.parser.IMessageHandler;
import org.eclipse.imp.parser.IParseController;
import org.eclipse.imp.parser.IParser;
import org.eclipse.imp.parser.ISourcePositionLocator;
import org.eclipse.imp.parser.MessageHandlerAdapter;
import org.eclipse.imp.parser.SimpleLPGParseController;

public class AS3ParseController extends SimpleLPGParseController implements IParseController {
        private AS3Parser parser;

        private AS3Lexer lexer;

        private Object backupAst;

        public AS3ParseController() {
                super(AS3Plugin.LANGUAGE);
        }

        /**
         * @param filePath
         *            Absolute path of file
         * @param project
         *            Project that contains the file
         * @param handler
         *            A message handler to receive error messages (or any others)
         *            from the parser
         */
        public void initialize(IPath filePath, ISourceProject project, IMessageHandler handler) {
                super.initialize(filePath, project, handler);
        }

        public IParser getParser() {
                return parser;
        }

        public ILexer getLexer() {
                return lexer;
        }

        public ISourcePositionLocator getNodeLocator() {
                return new AS3ASTNodeLocator();
        }

        public ILanguageSyntaxProperties getSyntaxProperties() {
                return new AS3SyntaxProperties();
        }


        public Object parse(String contents, IProgressMonitor monitor) {
                return parse(contents, false, monitor);
        }
        /**
         * setFilePath() should be called before calling this method.
         */
        public Object parse(String contents, boolean scanOnly, IProgressMonitor monitor) {
                PMMonitor my_monitor = new PMMonitor(monitor);
                char[] contentsArray = contents.toCharArray();

                if (lexer == null) {
                        lexer = new AS3Lexer();
                }
                lexer.reset(contentsArray, fFilePath.toPortableString());

                if (parser == null) {
                        parser = new AS3Parser(lexer.getILexStream());
                }
                parser.reset(lexer.getILexStream());
                parser.getIPrsStream().setMessageHandler(new AS3MessageHandler(handler));

                // Lex the stream to produce the token stream
                lexer.lexer(my_monitor, parser, true); 
                // fCurrentAst might (probably will) be
                // inconsistent wrt the lex stream now
                if (my_monitor.isCancelled()) return fCurrentAst;
                
                if (fCurrentAst != null)
                        backupAst = fCurrentAst;

                fCurrentAst = parser.parser(my_monitor, -1);

                if (fCurrentAst instanceof ASTNode) {
                        parser.resolve((ASTNode) fCurrentAst);
                }

                cacheKeywordsOnce();

                Object result = fCurrentAst;
                return result;
        }

        public Object getBackupAst() {
                return backupAst;
        }
}