org.eclipse.photran.core/model/org/eclipse/photran/internal/core/f95modelparser/FortranProcessor.java

package org.eclipse.photran.internal.core.f95modelparser;

import java.io.InputStream;
import java.util.Map;

import org.eclipse.cdt.internal.core.model.TranslationUnit;
import org.eclipse.core.runtime.Platform;
import org.eclipse.photran.core.FortranCorePlugin;
import org.eclipse.photran.internal.core.preferences.FortranEnableParserDebuggingPreference;
import org.eclipse.photran.internal.core.preferences.FortranPreferences;

/**
 * The entrypoint for lexing and parsing Fortran source code inside the Eclipse application. This
 * class should not be used in JUnit test cases.
 * 
 * @author joverbey
 */
public class FortranProcessor
{
    protected boolean lastParseWasFixedForm = false;
    
    /**
     * Determines whether or not the given file is a fixed-format file (based on its filename
     * extension) and returns a lexer capable of processing that file. Does <i>not</i> alter the
     * value returned by <code>lastParseWasFixedForm</code>.
     * @param inputStream the file's contents
     * @param filename the name of the file (with extension)
     * @return <code>ILexer</code>
     * @throws Exception
     */
    public static ILexer createLexerFor(InputStream inputStream, String filename) throws Exception
    {
        boolean isFixedForm = hasFixedFormFileExtension(filename);

        return Lexer.createLexer(inputStream, filename, isFixedForm);
    }

    /**
     * Parses the given input stream as a Fortran 95 source file. The filename parameter should
     * indicate the filename of the file being parsed; it is saved in each <code>Token</code>
     * produced and used in error messages, although no one actually checks to see if it's a legal
     * filename or not.
     * @param inputStream
     * @param filename
     * @param isFixedForm
     * @return <code>ParseResult</code>
     */
    public Map parseForModel(InputStream inputStream, String filename, Boolean isFixedForm, TranslationUnit tu) throws Exception
    {
        boolean isFixedFormB = isFixedForm == null ? hasFixedFormFileExtension(filename) : isFixedForm.booleanValue();
        //long startTime = System.currentTimeMillis();
        Parser parser = new Parser();
        Map/*<FortranElement, FortranElementInfo>*/ newElements = (Map)parse(inputStream, filename, isFixedFormB, parser, BuildModelParserAction.getInstance());
        //long endTime = System.currentTimeMillis();
        //System.out.println("Parse time for " + filename + ": " + (endTime - startTime) + " ms");
        return newElements;
    }

    protected Object parse(InputStream inputStream, String filename, boolean isFixedForm, Parser parser, AbstractParserAction parseAction) throws Exception
    {
        ILexer lexer = Lexer.createLexer(inputStream, filename, isFixedForm);

        try
        {
            Object result = parser.parse(lexer, parseAction);
            lastParseWasFixedForm = isFixedForm; // In case we processed other files while parsing
            return result;
        }
        catch (Exception e)
        {
            if (isParserDebuggingEnabled()) e.printStackTrace();
            throw e;
        }
    }

    public boolean lastParseWasFixedForm()
    {
        return lastParseWasFixedForm;
    }

    // -- USER PREFERENCE LOOKUPS ----------------------------------------

    /**
     * Ordinarily, we grab the list of fixed form file extensions from the user's preferences. In
     * test cases, however, the plugin doesn't exist, so we can't do that. So if you're parsing
     * outside the plugin, you must set the fixed form extensions this way, and this value will be
     * used rather than trying to load preferences from the user.
     */
    public static String[] overrideFixedFormExtensions = null;

    /**
     * Ordinarily, we grab determine whether parser debugging is enabled or not from the user's
     * preferences. In test cases, however, the plugin doesn't exist, so we can't do that. So if
     * you're parsing outside the plugin, you must set the property this way, and this value will be
     * used rather than trying to load preferences from the user. Typically, JUnit tests will set it
     * to false, since it causes a bunch of output on stdout/stderr that is useless to unit tests.
     */
    public static Boolean overrideIsParserDebuggingEnabled = null;

    /**
     * Looks at the user's preferences to determine whether the given filename has an extension
     * corresponding to fixed source form.
     * 
     * @param filename
     * @return <code>true</code> iff fixed form filename
     */
    public static boolean hasFixedFormFileExtension(String filename)
    {
        if (overrideFixedFormExtensions != null) // Used by JUnit tests
        {
            for (int i = 0; i < overrideFixedFormExtensions.length; i++)
                if (filename.endsWith(overrideFixedFormExtensions[i]))
                    return true;
            return false;
        }
        else
        {
            return Platform.getContentTypeManager().findContentTypeFor(filename).getId().equals(FortranCorePlugin.FIXED_FORM_CONTENT_TYPE);
        }
    }

    /**
     * Looks at the user's preferences to determine whether parser debugging has been enabled.
     * 
     * @param filename
     * @return <code>true</code> iff parser debugging enabled
     */
    public static boolean isParserDebuggingEnabled()
    {
        if (overrideIsParserDebuggingEnabled != null)
            return overrideIsParserDebuggingEnabled.booleanValue();

        FortranEnableParserDebuggingPreference pref = FortranPreferences.ENABLE_PARSER_DEBUGGING;
        return pref.getValue(FortranCorePlugin.getDefault().getPluginPreferences());
    }

    /**
     * Prints the given string to standard output iff the user's preferences indicate that parser
     * debugging has been enabled.
     * 
     * @param filename
     */
    public static void printDebug(String message)
    {
        if (isParserDebuggingEnabled()) System.out.println(message);
    }
}