Attachment #168076 for bug #312249

View | Details | Raw Unified | Return to bug 312249
Collapse All | Expand All

Lines 10-17 Link Here

(-)model/org/eclipse/photran/internal/core/model/SimpleFortranModelBuilder.java (-3 / +3 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.photran.internal.core.model;	11	package org.eclipse.photran.internal.core.model;
12		12
13	import java.io.ByteArrayInputStream;	13	import java.io.Reader;
14	import java.io.InputStream;	14	import java.io.StringReader;
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.HashMap;	16	import java.util.HashMap;
17	import java.util.Map;	17	import java.util.Map;
Lines 73-79 Link Here
73	{	73	{
74	this.newElements = new HashMap();	74	this.newElements = new HashMap();
75		75
76	InputStream in = new ByteArrayInputStream(translationUnit.getBuffer().getContents().getBytes());	76	Reader in = new StringReader(translationUnit.getBuffer().getContents());
77	String filename = translationUnit.getElementName();	77	String filename = translationUnit.getElementName();
78	boolean wasSuccessful = true;	78	boolean wasSuccessful = true;
79		79

Lines 1-6 Link Here

(-)model/org/eclipse/photran/internal/core/model/FortranModelBuilder.java (-2 / +2 lines)
1	package org.eclipse.photran.internal.core.model;	1	package org.eclipse.photran.internal.core.model;
2		2
3	import java.io.ByteArrayInputStream;	3	import java.io.StringReader;
4	import java.util.HashMap;	4	import java.util.HashMap;
5	import java.util.Map;	5	import java.util.Map;
6		6
Lines 74-80 Link Here
74	SourceForm sourceForm = determineSourceForm(file);	74	SourceForm sourceForm = determineSourceForm(file);
75	String filename = determineFilename(file);	75	String filename = determineFilename(file);
76	lexer = LexerFactory.createLexer(	76	lexer = LexerFactory.createLexer(
77	new ByteArrayInputStream(translationUnit.getBuffer().getContents().getBytes()),	77	new StringReader(translationUnit.getBuffer().getContents()),
78	file,	78	file,
79	filename,	79	filename,
80	sourceForm,	80	sourceForm,




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

import java.util.regex.Pattern;
import java.io.Reader;
import org.eclipse.core.resources.IFile;

@SuppressWarnings("unused")


    private TokenFactory tokenFactory;

    public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {
        this(new LineAppendingReader(in));
        this.prepass=_prepass;
        this.tokenFactory = tokenFactory;
    }


    private String filename = "<stdin>";

    public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)
    {
        this(in, _prepass, tokenFactory);
        this.lastTokenFile = new FileOrIFile(file);




 */

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

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import org.eclipse.core.resources.IFile;

@SuppressWarnings("unused")

    private String filename = "<stdin>";
    protected TokenFactory tokenFactory;

    public FreeFormLexerPhase1(Reader in, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)
    {
        this(new LineAppendingReader(in));
        this.lastTokenFile = new FileOrIFile(file);
        this.filename = filename;
        this.tokenFactory = tokenFactory;




/* The following code was generated by JFlex 1.4.1 on 5/11/10 8:56 PM */

/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.

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

import java.util.regex.Pattern;
import java.io.Reader;
import org.eclipse.core.resources.IFile;

@SuppressWarnings("unused")

/**
 * This class is a scanner generated by 
 * <a href="http://www.jflex.de/">JFlex</a> 1.4.1
 * on 5/11/10 8:56 PM from the specification file
 * <tt>FixedFormLexerPhase1.flex</tt>
 */
class FixedFormLexerPhase1 implements ILexer {


    private TokenFactory tokenFactory;

    public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {
        this(new LineAppendingReader(in));
        this.prepass=_prepass;
        this.tokenFactory = tokenFactory;
    }


    private String filename = "<stdin>";

    public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)
    {
        this(in, _prepass, tokenFactory);
        this.lastTokenFile = new FileOrIFile(file);




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

import java.io.IOException;
import java.io.Reader;

import org.eclipse.core.resources.IFile;



    private IToken nextToken = null;

    public FixedFormLexerPhase2(Reader in, IFile file, String filename, TokenFactory tokenFactory)
    {
        final Reader input = new LineAppendingReader(in);
        final FixedFormLexerPrepass prepass = new FixedFormLexerPrepass(input);
        Reader prepassReader = new SingleCharReader()
        {
            @Override
            public int read() throws IOException
            {
                try

                    return -1;
                }
            }
            
            @Override
            public void close() throws IOException
            {
                input.close();
            }
        };

        FixedFormLexerPhase1 fixedLexer1 = new FixedFormLexerPhase1(prepassReader, prepass, file, filename, tokenFactory);

Lines 64-72 Link Here

(-)lexer/org/eclipse/photran/internal/core/lexer/FixedFormLexerPrepass.java (-3 / +3 lines)
64	this.in = new OffsetLineReader(in);	64	this.in = new OffsetLineReader(in);
65	}	65	}
66		66
67	public FixedFormLexerPrepass(InputStream in) {	67	// public FixedFormLexerPrepass(InputStream in) {
68	this(new InputStreamReader(in));	68	// this(new InputStreamReader(in));
69	}	69	// }
70		70
71	public int getLine(int absCharPos) {	71	public int getLine(int absCharPos) {
72	if (absCharPos<0) return 0;	72	if (absCharPos<0) return 0;




/* The following code was generated by JFlex 1.4.1 on 5/11/10 8:56 PM */

/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.

 */

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

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import org.eclipse.core.resources.IFile;

@SuppressWarnings("unused")

/**
 * This class is a scanner generated by 
 * <a href="http://www.jflex.de/">JFlex</a> 1.4.1
 * on 5/11/10 8:56 PM from the specification file
 * <tt>FreeFormLexerPhase1.flex</tt>
 */
public class FreeFormLexerPhase1 implements ILexer {

    private String filename = "<stdin>";
    protected TokenFactory tokenFactory;

    public FreeFormLexerPhase1(Reader in, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)
    {
        this(new LineAppendingReader(in));
        this.lastTokenFile = new FileOrIFile(file);
        this.filename = filename;
        this.tokenFactory = tokenFactory;




        this.currentInputStream = originalInputStream;
    }

    @Override
    public int read() throws IOException
    {
        int result = currentInputStream.read();

        {
            currentInputStream = eolInputStream;
            result = currentInputStream.read();
            currentInputStream.available();
        }
        else
        {

        private static final byte[] EOL = System.getProperty("line.separator").getBytes();
        private int eolByte = 0;

        @Override
        public int read() throws IOException
        {
            return eolByte < EOL.length ? EOL[eolByte++] : -1;




/*******************************************************************************
 * Copyright (c) 2007 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.Reader;

/**
 * Wraps another <code>Reader</code>, and, if the wrapped stream does not end
 * with an end-of-line character, appends the OS-dependent end-of-line sequence to
 * the end of the stream.
 * 
 * @author Jeff Overbey
 */
public final class LineAppendingReader extends SingleCharReader
{
    private Reader originalReader;
    private Reader eolReader;
    private Reader currentReader;
    
    private int lastChar = -1;
    
    public LineAppendingReader(Reader streamToWrap)
    {
        this.originalReader = streamToWrap;
        this.eolReader = new EOLReader();
        
        this.currentReader = originalReader;
    }

    @Override
    public int read() throws IOException
    {
        int result = currentReader.read();
        
        if (result == -1 && currentReader == originalReader && !isEOL(lastChar))
        {
            currentReader = eolReader;
            result = currentReader.read();
        }
        else
        {
            lastChar = result;
        }
        
        return result;
    }

    private boolean isEOL(int c)
    {
        return c =='\n' || c == '\r';
    }

    @Override
    public void close() throws IOException
    {
        originalReader.close();
    }

    private static class EOLReader extends SingleCharReader
    {
        private static final byte[] EOL = System.getProperty("line.separator").getBytes();
        private int eolByte = 0;

        @Override
        public int read() throws IOException
        {
            return eolByte < EOL.length ? EOL[eolByte++] : -1;
        }

        @Override
        public void close() throws IOException
        {
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2007 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.InputStream;

/**
 * Java's <code>BufferedReader</code> can read a line of text from another
 * reader, but it omits the end-of-line character(s).  This one doesn't.
 * Subclass if necessary.
 * 
 * @author Jeff Overbey
 */
public final class LineInputStream extends InputStream implements CharSequence
{
    protected InputStream in;
    
    protected String filename;
    protected int startOffset;
    protected int startLineNum;
    protected int restartLine = -1;
    protected int restartOffset = -1;
    
    protected char[] currentLine = new char[4096];
    protected int currentLineLength = -1;
    protected int offsetInCurrentLine = -1;
    protected int offsetInStream = 0;
    protected int lineNumInCurrentStream = 0;
    protected boolean atEOF = false;

    public LineInputStream(InputStream readFrom, String filename) throws IOException
    {
        this(readFrom, filename, 0, 0);
    }

    public LineInputStream(InputStream readFrom, String filename, int startOffset, int startLineNum) throws IOException
    {
        this.in = readFrom;
        this.filename = filename;
        this.startOffset = startOffset;
        this.startLineNum = startLineNum;
        advanceToNextLine();
    }

    /**
     * THIS IS EXPENSIVE -- The text of the line is COPIED into a <code>String</code>.
     * @return
     * @throws IOException
     */
    public String currentLine() throws IOException
    {
        ensureLineLoaded();
        return atEOF() ? null : String.valueOf(currentLine, offsetInCurrentLine, currentLineLength-offsetInCurrentLine);
    }
    
    public boolean atBOL() throws IOException
    {
        ensureLineLoaded();
        return offsetInCurrentLine == 0;
    }
    
    public boolean atEOF() throws IOException
    {
        return offsetInCurrentLine >= currentLineLength && atEOF;
    }

    protected void ensureLineLoaded() throws IOException
    {
        if (!atEOF && offsetInCurrentLine >= currentLineLength)
            advanceToNextLine();
    }

    protected int peek() throws IOException
    {
        return atEOF() ? -1 : currentLine[offsetInCurrentLine];
    }

    public void advanceToNextLine() throws IOException
    {
        int c;
        
        offsetInCurrentLine = 0;
        offsetInStream += Math.max(currentLineLength-offsetInCurrentLine, 0);
        
        if (atEOF) return;
        
        lineNumInCurrentStream++;
        
        if (currentLineLength < 0)
        {
            // First attempt to read a line
            currentLineLength = 0;
        }
        else
        {
            // Start with the extra character from the last read
            currentLine[0] = currentLine[currentLineLength];
            currentLineLength = 1;
        }
        
        for (c = in.read(); c != -1 && c != '\n' && c != '\r'; c = in.read())
            append(c);
        
        if (c == -1) append('\n'); // Always end files with a newline
        
        for ( ; c != -1 && (c == '\n' || c == '\r'); c = in.read())
            append(c);
        
        if (c == -1) atEOF = true;

        // To find the end of the line, we had to read an extra character; don't lose it!
        currentLine[currentLineLength] = (char)c;
    }
    
    private void append(int c)
    {
        if (currentLineLength + 1 == currentLine.length)
        {
            char[] newCurrentLine = new char[currentLine.length*2];
            System.arraycopy(currentLine, 0, newCurrentLine, 0, currentLine.length);
            currentLine = newCurrentLine;
        }
        
        currentLine[currentLineLength++] = (char)c;
    }
    
    public String getFilename()
    {
        return filename;
    }
    
    public int getFileOffsetOfNextRead()
    {
        return offsetInStream;
    }
    
    public int getFileLineOfNextRead()
    {
        return lineNumInCurrentStream;
    }
    
    public int getTotalOffsetOfNextRead()
    {
        return startOffset + offsetInStream;
    }
    
    public int getTotalLineOfNextRead()
    {
        return startLineNum + lineNumInCurrentStream;
    }

    public int getStartLine()
    {
        return startLineNum;
    }

    public int getStartOffset()
    {
        return startOffset;
    }

    public int getRestartLine()
    {
        return restartLine;
    }

    public void setRestartLine(int restartLine)
    {
        this.restartLine = restartLine;
    }

    public int getRestartOffset()
    {
        return restartOffset;
    }

    public void setRestartOffset(int restartOffset)
    {
        this.restartOffset = restartOffset;
    }
    
    ///////////////////////////////////////////////////////////////////////////
    // INPUTSTREAM IMPLEMENTATION
    ///////////////////////////////////////////////////////////////////////////

    public int read() throws IOException
    {
        ensureLineLoaded();
        int result = peek();
        if (result >= 0)
        {
            offsetInCurrentLine++;
            offsetInStream++;
        }
        return result;
    }

    ///////////////////////////////////////////////////////////////////////////
    // CHARSEQUENCE IMPLEMENTATION
    ///////////////////////////////////////////////////////////////////////////
    
    public char charAt(int index)
    {
        return currentLine[offsetInCurrentLine+index];
    }

    public int length()
    {
        return currentLineLength-offsetInCurrentLine;
    }

    public CharSequence subSequence(final int start, final int end)
    {
        if (start < offsetInCurrentLine || end >= length())
            throw new IllegalArgumentException();
        
        return new SubSequence(start, end);
    }
    
    private final class SubSequence implements CharSequence
    {
        private final int start;
        private final int end;

        private SubSequence(int start, int end)
        {
            this.start = start;
            this.end = end;
        }

        public char charAt(int index)
        {
            return currentLine[offsetInCurrentLine+start];
        }

        public int length()
        {
            return end-start;
        }

        public CharSequence subSequence(int subseqStart, int subseqEnd)
        {
            return new SubSequence(start+subseqStart, start+subseqEnd);
        }
        
        public String toString()
        {
            return String.valueOf(currentLine, start, end-start);
        }
    }
}




/*******************************************************************************
 * Copyright (c) 2007 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.Reader;

/**
 * Java's <code>BufferedReader</code> can read a line of text from another
 * reader, but it omits the end-of-line character(s).  This one doesn't.
 * Subclass if necessary.
 * 
 * @author Jeff Overbey
 */
public final class LineReader extends SingleCharReader implements CharSequence
{
    protected Reader in;
    
    protected String filename;
    protected int startOffset;
    protected int startLineNum;
    protected int restartLine = -1;
    protected int restartOffset = -1;
    
    protected char[] currentLine = new char[4096];
    protected int currentLineLength = -1;
    protected int offsetInCurrentLine = -1;
    protected int offsetInStream = 0;
    protected int lineNumInCurrentStream = 0;
    protected boolean atEOF = false;

    public LineReader(Reader readFrom, String filename) throws IOException
    {
        this(readFrom, filename, 0, 0);
    }

    public LineReader(Reader readFrom, String filename, int startOffset, int startLineNum) throws IOException
    {
        this.in = readFrom;
        this.filename = filename;
        this.startOffset = startOffset;
        this.startLineNum = startLineNum;
        advanceToNextLine();
    }

    /**
     * THIS IS EXPENSIVE -- The text of the line is COPIED into a <code>String</code>.
     * @return
     * @throws IOException
     */
    public String currentLine() throws IOException
    {
        ensureLineLoaded();
        return atEOF() ? null : String.valueOf(currentLine, offsetInCurrentLine, currentLineLength-offsetInCurrentLine);
    }
    
    public boolean atBOL() throws IOException
    {
        ensureLineLoaded();
        return offsetInCurrentLine == 0;
    }
    
    public boolean atEOF() throws IOException
    {
        return offsetInCurrentLine >= currentLineLength && atEOF;
    }

    protected void ensureLineLoaded() throws IOException
    {
        if (!atEOF && offsetInCurrentLine >= currentLineLength)
            advanceToNextLine();
    }

    protected int peek() throws IOException
    {
        return atEOF() ? -1 : currentLine[offsetInCurrentLine];
    }

    public void advanceToNextLine() throws IOException
    {
        int c;
        
        offsetInCurrentLine = 0;
        offsetInStream += Math.max(currentLineLength-offsetInCurrentLine, 0);
        
        if (atEOF) return;
        
        lineNumInCurrentStream++;
        
        if (currentLineLength < 0)
        {
            // First attempt to read a line
            currentLineLength = 0;
        }
        else
        {
            // Start with the extra character from the last read
            currentLine[0] = currentLine[currentLineLength];
            currentLineLength = 1;
        }
        
        for (c = in.read(); c != -1 && c != '\n' && c != '\r'; c = in.read())
            append(c);
        
        if (c == -1) append('\n'); // Always end files with a newline
        
        for ( ; c != -1 && (c == '\n' || c == '\r'); c = in.read())
            append(c);
        
        if (c == -1) atEOF = true;

        // To find the end of the line, we had to read an extra character; don't lose it!
        currentLine[currentLineLength] = (char)c;
    }
    
    private void append(int c)
    {
        if (currentLineLength + 1 == currentLine.length)
        {
            char[] newCurrentLine = new char[currentLine.length*2];
            System.arraycopy(currentLine, 0, newCurrentLine, 0, currentLine.length);
            currentLine = newCurrentLine;
        }
        
        currentLine[currentLineLength++] = (char)c;
    }
    
    public String getFilename()
    {
        return filename;
    }
    
    public int getFileOffsetOfNextRead()
    {
        return offsetInStream;
    }
    
    public int getFileLineOfNextRead()
    {
        return lineNumInCurrentStream;
    }
    
    public int getTotalOffsetOfNextRead()
    {
        return startOffset + offsetInStream;
    }
    
    public int getTotalLineOfNextRead()
    {
        return startLineNum + lineNumInCurrentStream;
    }

    public int getStartLine()
    {
        return startLineNum;
    }

    public int getStartOffset()
    {
        return startOffset;
    }

    public int getRestartLine()
    {
        return restartLine;
    }

    public void setRestartLine(int restartLine)
    {
        this.restartLine = restartLine;
    }

    public int getRestartOffset()
    {
        return restartOffset;
    }

    public void setRestartOffset(int restartOffset)
    {
        this.restartOffset = restartOffset;
    }
    
    ///////////////////////////////////////////////////////////////////////////
    // INPUTSTREAM IMPLEMENTATION
    ///////////////////////////////////////////////////////////////////////////

    public int read() throws IOException
    {
        ensureLineLoaded();
        int result = peek();
        if (result >= 0)
        {
            offsetInCurrentLine++;
            offsetInStream++;
        }
        return result;
    }

    ///////////////////////////////////////////////////////////////////////////
    // CHARSEQUENCE IMPLEMENTATION
    ///////////////////////////////////////////////////////////////////////////
    
    public char charAt(int index)
    {
        return currentLine[offsetInCurrentLine+index];
    }

    public int length()
    {
        return currentLineLength-offsetInCurrentLine;
    }

    public CharSequence subSequence(final int start, final int end)
    {
        if (start < offsetInCurrentLine || end >= length())
            throw new IllegalArgumentException();
        
        return new SubSequence(start, end);
    }
    
    private final class SubSequence implements CharSequence
    {
        private final int start;
        private final int end;

        private SubSequence(int start, int end)
        {
            this.start = start;
            this.end = end;
        }

        public char charAt(int index)
        {
            return currentLine[offsetInCurrentLine+start];
        }

        public int length()
        {
            return end-start;
        }

        public CharSequence subSequence(int subseqStart, int subseqEnd)
        {
            return new SubSequence(start+subseqStart, start+subseqEnd);
        }
        
        public String toString()
        {
            return String.valueOf(currentLine, start, end-start);
        }
    }

    @Override
    public void close() throws IOException
    {
        in.close();
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.Reader;


/**
 * Copied from org.eclipse.jface.internal.text.html.SingleCharReader
 * <p>
 * Moved into this package from <code>org.eclipse.jface.internal.text.revisions</code>.</p>
 */
public abstract class SingleCharReader extends Reader {

	/**
	 * @see Reader#read()
	 */
	public abstract int read() throws IOException;

	/**
	 * @see Reader#read(char[],int,int)
	 */
	public int read(char cbuf[], int off, int len) throws IOException {
		int end= off + len;
		for (int i= off; i < end; i++) {
			int ch= read();
			if (ch == -1) {
				if (i == off)
					return -1;
				return i - off;
			}
			cbuf[i]= (char)ch;
		}
		return len;
	}

	/**
	 * @see Reader#ready()
	 */
    public boolean ready() throws IOException {
		return true;
	}

	/**
	 * Returns the readable content as string.
	 * @return the readable content as string
	 * @exception IOException in case reading fails
	 */
	public String getString() throws IOException {
		StringBuffer buf= new StringBuffer();
		int ch;
		while ((ch= read()) != -1) {
			buf.append((char)ch);
		}
		return buf.toString();
	}
}




 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;

{
    private LexerFactory() {;}
    
    public static IAccumulatingLexer createLexer(Reader in, IFile file, String filename, SourceForm sourceForm, boolean accumulateWhitetext) throws IOException
    {
        return sourceForm.createLexer(in, file, filename, accumulateWhitetext);
    }
    
    public static IAccumulatingLexer createLexer(File file, SourceForm sourceForm, boolean accumulateWhitetext) throws IOException
    {
        return createLexer(new BufferedReader(new FileReader(file)), null, file.getAbsolutePath(), sourceForm, accumulateWhitetext);
    }
    
    public static IAccumulatingLexer createLexer(IFile file, SourceForm sourceForm, boolean accumulateWhitetext) throws CoreException, IOException
    {
        return createLexer(new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset())),
            file,
            determineFilename(file),
            sourceForm,
            accumulateWhitetext);
    }

    private static String determineFilename(IFile file)





import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;

import org.eclipse.photran.internal.core.FortranCorePlugin;
import org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include.IncludeLoaderCallback;
import org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include.PreprocessingFreeFormLexerPhase1;
import org.eclipse.photran.internal.core.vpg.PhotranVPG;

/**
 * Contains constants enumerating the various Fortran source forms (fixed form, free form, free

     *     </ol>
     * </ol>
     */
    public abstract IAccumulatingLexer createLexer(Reader in, IFile file, String filename, boolean accumulateWhitetext) throws IOException;
    
    public abstract String getDescription(String filename);
    
    public static final SourceForm UNPREPROCESSED_FREE_FORM = new SourceForm()
    {
        @Override public IAccumulatingLexer createLexer(Reader in, IFile file, String filename, boolean accumulateWhitetext) throws IOException
        {
            return new LexerPhase3(new FreeFormLexerPhase2(new FreeFormLexerPhase1(in, file, filename, ASTTokenFactory.getInstance(), accumulateWhitetext)));
        }

    
    public static final SourceForm FIXED_FORM = new SourceForm()
    {
        @Override public IAccumulatingLexer createLexer(Reader in, IFile file, String filename, boolean accumulateWhitetext) throws IOException
        {
            return new LexerPhase3(new FixedFormLexerPhase2(in, file, filename, ASTTokenFactory.getInstance()));
        }

    {
        return new SourceForm()
        {
            @Override public IAccumulatingLexer createLexer(Reader in, IFile file, String filename, boolean accumulateWhitetext) throws IOException
            {
                SourceForm sf = findPreferredSourceForm(filename);
                if (sf != null)





import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;


import org.eclipse.core.resources.IFile;
import org.eclipse.photran.internal.core.lexer.FreeFormLexerPhase1;
import org.eclipse.photran.internal.core.lexer.LineReader;
import org.eclipse.photran.internal.core.lexer.SingleCharReader;

/**
 * An <code>Reader</code> that recognizes and processes Fortran INCLUDE lines.
 * <p> 
 * This class implements an {@link Reader} the provides the contents of a
 * Fortran file <i>after</i> INCLUDE lines have been processed.  Photran's
 * machine-constructed, free-form lexer ({@link FreeFormLexerPhase1}) tokenizes
 * this Reader, oblivious to the fact that it is actually tokenizing
 * preprocessed text.  However, a special subclass
 * ({@link PreprocessingFreeFormLexerPhase1}) takes care of mapping the
 * preprocessed tokens back to their images and locations in the original files.

 * 
 * @author Jeff Overbey
 */
public final class FortranPreprocessor extends SingleCharReader
{
    /**
     * Utility class.  Originally, we simply used a <pre>Stack<LineReader></pre>,
     * but a profile revealed that Stack#peek was consuming a large amount of time
     * due to repeated invocations.  Now, the #topStream field in this class is
     * accessed instead, resulting in a significant performance improvement

     */
    private static final class StreamStack
    {
        private Stack<LineReader> streamStack = new Stack<LineReader>();
        private LineReader topStream = null;
        
        public void push(LineReader lineReader)
        {
            streamStack.push(lineReader);
            topStream = lineReader;
        }

        public int size()

    private ArrayList<Integer> fileStartLines;
    private ArrayList<Integer> fileStartLineAdjustments;
    
    public FortranPreprocessor(Reader readFrom, IFile file, String filename, IncludeLoaderCallback callback) throws IOException
    {
        this.topLevelFile = file;
        this.callback = callback;
        
        streamStack = new StreamStack();
        streamStack.push(new LineReader(readFrom, filename));
        
        directivesInTopLevelFile = new LinkedList<FortranIncludeDirective>();
        directivesInTopLevelFile.add(null);

        throw new IllegalArgumentException();
    }
    
    @Override
    public int read() throws IOException
    {
        LineReader currentStream = streamStack.topStream;
        if (currentStream.atBOL()) checkForInclude();
        currentStream = streamStack.topStream;
        if (currentStream.atEOF()) finishInclude();

        Matcher m = INCLUDE_LINE.matcher(streamStack.topStream);
        if (m.matches())
        {
            LineReader origStream = streamStack.topStream;
            String includeLine = origStream.currentLine();
            String fileToInclude = m.group(INCLUDE_LINE_CAPTURING_GROUP_OF_FILENAME);
            
            Reader newStream = findIncludedFile(fileToInclude);
            if (newStream != null)
            {
                if (inTopLevelFile())

                origStream.setRestartOffset(offset + includeLine.length());
                origStream.setRestartLine(line + 1);
                
                streamStack.push(new LineReader(newStream, fileToInclude, offset, line));
                
                fileNames.add(fileToInclude);
                fileStartOffsets.add(new Integer(offset));

        }
    }

    protected Reader findIncludedFile(String fileToInclude) throws IOException
    {
        try
        {

    {
        return topLevelFile;
    }

    @Override
    public void close() throws IOException
    {
        streamStack.topStream.close();
    }
}

Lines 10-17 Link Here

(-)parser/org/eclipse/photran/internal/core/lexer/preprocessor/fortran_include/IncludeLoaderCallback.java (-3 / +14 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include;	11	package org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include;
12		12
		13	import java.io.BufferedReader;
13	import java.io.FileNotFoundException;	14	import java.io.FileNotFoundException;
14	import java.io.InputStream;	15	import java.io.InputStreamReader;
		16	import java.io.Reader;
		17	import java.io.UnsupportedEncodingException;
15		18
16	import org.eclipse.core.resources.IContainer;	19	import org.eclipse.core.resources.IContainer;
17	import org.eclipse.core.resources.IFile;	20	import org.eclipse.core.resources.IFile;
Lines 44-54 Link Here
44	* @return <code>InputStream</code>, not null	47	* @return <code>InputStream</code>, not null
45	* @throws FileNotFoundException if the file cannot be found	48	* @throws FileNotFoundException if the file cannot be found
46	*/	49	*/
47	public InputStream getIncludedFileAsStream(String fileToInclude) throws FileNotFoundException	50	public Reader getIncludedFileAsStream(String fileToInclude) throws FileNotFoundException
48	{	51	{
49	try	52	try
50	{	53	{
51	return getIncludedFile(fileToInclude).getContents(true);	54	IFile file = getIncludedFile(fileToInclude);
		55	try
		56	{
		57	return new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset()));
		58	}
		59	catch (UnsupportedEncodingException e)
		60	{
		61	return new BufferedReader(new InputStreamReader(file.getContents(true)));
		62	}
52	}	63	}
53	catch (CoreException e)	64	catch (CoreException e)
54	{	65	{





import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

import org.eclipse.core.resources.IFile;
import org.eclipse.photran.internal.core.lexer.ASTTokenFactory;
import org.eclipse.photran.internal.core.lexer.FreeFormLexerPhase1;
import org.eclipse.photran.internal.core.lexer.LexerException;
import org.eclipse.photran.internal.core.lexer.LineAppendingReader;
import org.eclipse.photran.internal.core.lexer.Token;
import org.eclipse.photran.internal.core.lexer.TokenFactory;


    private FortranPreprocessor preprocessor;
    private FortranIncludeDirective lastDirective;

    public PreprocessingFreeFormLexerPhase1(Reader in, IFile file, String filename, IncludeLoaderCallback callback, boolean accumulateWhitetext) throws IOException
    {
        this(new FortranPreprocessor(new LineAppendingReader(in), file, filename, callback), file, filename, ASTTokenFactory.getInstance(), accumulateWhitetext);
    }
    
    // This would not be here if we could assign the preprocessor to a variable in the above ctor (grrr)

Lines 11-16 Link Here

(-)src/org/eclipse/photran/internal/core/refactoring/infrastructure/FortranResourceRefactoring.java (-1 / +4 lines)
11	package org.eclipse.photran.internal.core.refactoring.infrastructure;	11	package org.eclipse.photran.internal.core.refactoring.infrastructure;
12		12
13	import java.io.ByteArrayInputStream;	13	import java.io.ByteArrayInputStream;
		14	import java.io.InputStreamReader;
		15	import java.nio.charset.Charset;
14	import java.util.ArrayList;	16	import java.util.ArrayList;
15	import java.util.Arrays;	17	import java.util.Arrays;
16	import java.util.Collection;	18	import java.util.Collection;
Lines 271-278 Link Here
271	{	273	{
272	try	274	try
273	{	275	{
		276	final String charset = Charset.defaultCharset().name();
274	IAccumulatingLexer lexer = LexerFactory.createLexer(	277	IAccumulatingLexer lexer = LexerFactory.createLexer(
275	new ByteArrayInputStream(string.getBytes()), null, "(none)",	278	new InputStreamReader(new ByteArrayInputStream(string.getBytes(charset)), charset), null, "(none)",
276	SourceForm.UNPREPROCESSED_FREE_FORM, true);	279	SourceForm.UNPREPROCESSED_FREE_FORM, true);
277	Parser parser = new Parser();	280	Parser parser = new Parser();
278		281




 *******************************************************************************/
package org.eclipse.photran.internal.core.vpg;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.List;

import org.eclipse.core.resources.IFile;

import org.eclipse.photran.internal.core.SyntaxException;
import org.eclipse.photran.internal.core.analysis.binding.Binder;
import org.eclipse.photran.internal.core.analysis.binding.Definition;
import org.eclipse.photran.internal.core.analysis.binding.Definition.Visibility;
import org.eclipse.photran.internal.core.analysis.binding.ImplicitSpec;
import org.eclipse.photran.internal.core.analysis.binding.ScopingNode;
import org.eclipse.photran.internal.core.analysis.binding.Definition.Visibility;
import org.eclipse.photran.internal.core.lexer.IAccumulatingLexer;
import org.eclipse.photran.internal.core.lexer.LexerException;
import org.eclipse.photran.internal.core.lexer.LexerFactory;

            sourceForm = SourceForm.preprocessedFreeForm(new IncludeLoaderCallback(file.getProject())
            {
                @Override
                public Reader getIncludedFileAsStream(String fileToInclude) throws FileNotFoundException
                {
                    // When we encounter an INCLUDE directive, set up a file dependency in the VPG


        if (ast == null)
            throw new IllegalArgumentException(filename + " returned null AST");
        
        try
        {
            final String charset = Charset.defaultCharset().name(); // Platform's default charset
            ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
            ast.getRoot().printOn(new PrintStream(out, false, charset), null);
            ast = parse(filename, new InputStreamReader(new ByteArrayInputStream(out.toByteArray()), charset));

            computeEdgesAndAnnotations(filename, ast);
        }
        catch (UnsupportedEncodingException e)
        {
            throw new Error(e);
        }
    }

    @Override public String getSourceCodeFromAST(IFortranAST ast)

        return parse(filename, null);
    }

    private IFortranAST parse(final String filename, Reader stream)
    {
        if (filename == null || isVirtualFile(filename)) return null;


            SourceForm sourceForm = determineSourceForm(filename);
            try
            {
                if (stream == null) stream = new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset()));
                IAccumulatingLexer lexer = LexerFactory.createLexer(stream, file, filename, sourceForm, true);
                long start = System.currentTimeMillis();
                ASTExecutableProgramNode ast = parser.parse(lexer);

Lines 11-17 Link Here

(-)src/org/eclipse/photran/internal/core/lexer/CPreprocessedSourceForm.java (-2 / +2 lines)
11	package org.eclipse.photran.internal.core.lexer;	11	package org.eclipse.photran.internal.core.lexer;
12		12
13	import java.io.IOException;	13	import java.io.IOException;
14	import java.io.InputStream;	14	import java.io.Reader;
15		15
16	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
17	import org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include.IncludeLoaderCallback;	17	import org.eclipse.photran.internal.core.lexer.preprocessor.fortran_include.IncludeLoaderCallback;
Lines 30-36 Link Here
30	this.callback = callback;	30	this.callback = callback;
31	}	31	}
32		32
33	@Override public IAccumulatingLexer createLexer(InputStream in, IFile file, String filename, boolean accumulateWhitetext) throws IOException	33	@Override public IAccumulatingLexer createLexer(Reader in, IFile file, String filename, boolean accumulateWhitetext) throws IOException
34	{	34	{
35	return new LexerPhase3(new FreeFormLexerPhase2(new CPreprocessingFreeFormLexerPhase1(in, file, filename, callback, accumulateWhitetext)));	35	return new LexerPhase3(new FreeFormLexerPhase2(new CPreprocessingFreeFormLexerPhase1(in, file, filename, callback, accumulateWhitetext)));
36	}	36	}

Lines 10-17 Link Here

(-)src/org/eclipse/photran/internal/core/lexer/CPreprocessingFreeFormLexerPhase1.java (-4 / +8 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.photran.internal.core.lexer;	11	package org.eclipse.photran.internal.core.lexer;
12		12
		13	import java.io.BufferedReader;
13	import java.io.IOException;	14	import java.io.IOException;
14	import java.io.InputStream;	15	import java.io.InputStream;
		16	import java.io.InputStreamReader;
		17	import java.io.Reader;
		18	import java.nio.charset.Charset;
15	import java.util.ArrayList;	19	import java.util.ArrayList;
16		20
17	import org.eclipse.core.resources.IFile;	21	import org.eclipse.core.resources.IFile;
Lines 20-26 Link Here
20	/**	24	/**
21	* Phase 1 lexer that handles C preprocessor directives.	25	* Phase 1 lexer that handles C preprocessor directives.
22	* <p>	26	* <p>
23	* This class feeds {@link FreeFormLexerPhase1} with a {@link CPreprocessingInputStream},	27	* This class feeds {@link FreeFormLexerPhase1} with a {@link CPreprocessingReader},
24	* an {@link InputStream} that interprets C preprocessor directives.	28	* an {@link InputStream} that interprets C preprocessor directives.
25	* {@link FreeFormLexerPhase1} tokenizes the preprocessed stream. However, this	29	* {@link FreeFormLexerPhase1} tokenizes the preprocessed stream. However, this
26	* class subclasses {@link FreeFormLexerPhase1} and overrides its tokenization	30	* class subclasses {@link FreeFormLexerPhase1} and overrides its tokenization
Lines 49-61 Link Here
49		53
50	private Token lastReadInFile = null;	54	private Token lastReadInFile = null;
51		55
52	public CPreprocessingFreeFormLexerPhase1(InputStream in, IFile file, String filename, IncludeLoaderCallback callback, boolean accumulateWhitetext) throws IOException	56	public CPreprocessingFreeFormLexerPhase1(Reader in, IFile file, String filename, IncludeLoaderCallback callback, boolean accumulateWhitetext) throws IOException
53	{	57	{
54	this(new CPreprocessingInputStream(file, filename, new LineAppendingInputStream(in)), file, filename, ASTTokenFactory.getInstance(), accumulateWhitetext);	58	this(new CPreprocessingReader(file, filename, new LineAppendingReader(in)), file, filename, ASTTokenFactory.getInstance(), accumulateWhitetext);
55	}	59	}
56		60
57	// This would not be here if we could assign the preprocessor to a variable in the above ctor (grrr)	61	// This would not be here if we could assign the preprocessor to a variable in the above ctor (grrr)
58	private CPreprocessingFreeFormLexerPhase1(CPreprocessingInputStream cpp, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)	62	private CPreprocessingFreeFormLexerPhase1(CPreprocessingReader cpp, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)
59	{	63	{
60	super(cpp, file, filename, tokenFactory, accumulateWhitetext);	64	super(cpp, file, filename, tokenFactory, accumulateWhitetext);
61	this.producerMap = cpp.getProducerMap();	65	this.producerMap = cpp.getProducerMap();




/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.InputStream;

import org.eclipse.core.resources.IFile;
import org.eclipse.photran.internal.core.preprocessor.c.CppHelper;
import org.eclipse.photran.internal.core.preprocessor.c.IToken;
import org.eclipse.photran.internal.core.preprocessor.c.OffsetLimitReachedException;

/**
 * An InputStream to read tokens obtained from the CPP. This class will
 * also make a ProducerMap when constructed that can be used to find
 * directives and macros.
 * 
 * @author Matthew Michelotti
 */
public class CPreprocessingInputStream extends InputStream
{
	/**ProducerMap constructed from the CPP tokens*/
	private ProducerMap producerMap;
	
	private IncludeMap includeMap;

	/**current CPP token being read*/
	private IToken curToken;
	/**full image of curToken*/
	private String curTokenImage;
	/**the offset in curTokenImage to be read next*/
	private int curTokenOffset = 0;
	
	/**
	 * Basic constructor. Parses the whole file in the constructor
	 * and turns the result into CPP tokens. A ProducerMap is made
	 * from these tokens. The tokens are remembered, so that they
	 * can be read as an input stream.
	 * @param filename - name of file that inputStream corresponds to
	 * @param inputStream - InputStream to read file data from
	 * @throws IOException
	 */
	public CPreprocessingInputStream(IFile file, String filename, InputStream inputStream) throws IOException
	{
		try
		{
			CppHelper cpp = new CppHelper(file, filename, inputStream);
			curToken = cpp.getRemainingTokens();
			curTokenImage = CppHelper.getFullImage(curToken);
			producerMap = new ProducerMap(curToken);
			includeMap = new IncludeMap(curToken, file);
		}catch(OffsetLimitReachedException e) {throw new Error(e);}
	}
	
	@Override public int read() throws IOException
	{
		if(curToken == null) return -1;
		while(curTokenOffset >= curTokenImage.length()) {
			curToken = curToken.getNext();
			if(curToken == null) return -1;
			curTokenImage = CppHelper.getFullImage(curToken);
			curTokenOffset = 0;
		}
		char result = curTokenImage.charAt(curTokenOffset);
		curTokenOffset++;
		
		return result;
	}
	
	/**@return the ProducerMap object made at construction*/
	public ProducerMap getProducerMap() {
		return producerMap;
	}
	
	public IncludeMap getIncludeMap() {
		return includeMap;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.lexer;

import java.io.IOException;
import java.io.Reader;

import org.eclipse.core.resources.IFile;
import org.eclipse.photran.internal.core.preprocessor.c.CppHelper;
import org.eclipse.photran.internal.core.preprocessor.c.IToken;
import org.eclipse.photran.internal.core.preprocessor.c.OffsetLimitReachedException;

/**
 * An InputStream to read tokens obtained from the CPP. This class will
 * also make a ProducerMap when constructed that can be used to find
 * directives and macros.
 * 
 * @author Matthew Michelotti
 */
public class CPreprocessingReader extends SingleCharReader
{
	/**ProducerMap constructed from the CPP tokens*/
	private ProducerMap producerMap;
	
	private IncludeMap includeMap;

	/**current CPP token being read*/
	private IToken curToken;
	/**full image of curToken*/
	private String curTokenImage;
	/**the offset in curTokenImage to be read next*/
	private int curTokenOffset = 0;
	
	/**
	 * Basic constructor. Parses the whole file in the constructor
	 * and turns the result into CPP tokens. A ProducerMap is made
	 * from these tokens. The tokens are remembered, so that they
	 * can be read as an input stream.
	 * @param filename - name of file that inputStream corresponds to
	 * @param reader - Reader to read file data from
	 * @throws IOException
	 */
	public CPreprocessingReader(IFile file, String filename, Reader reader) throws IOException
	{
		try
		{
			CppHelper cpp = new CppHelper(file, filename, reader);
			curToken = cpp.getRemainingTokens();
			curTokenImage = CppHelper.getFullImage(curToken);
			producerMap = new ProducerMap(curToken);
			includeMap = new IncludeMap(curToken, file);
		}catch(OffsetLimitReachedException e) {throw new Error(e);}
	}
	
	@Override public int read() throws IOException
	{
		if(curToken == null) return -1;
		while(curTokenOffset >= curTokenImage.length()) {
			curToken = curToken.getNext();
			if(curToken == null) return -1;
			curTokenImage = CppHelper.getFullImage(curToken);
			curTokenOffset = 0;
		}
		char result = curTokenImage.charAt(curTokenOffset);
		curTokenOffset++;
		
		return result;
	}
	
	/**@return the ProducerMap object made at construction*/
	public ProducerMap getProducerMap() {
		return producerMap;
	}
	
	public IncludeMap getIncludeMap() {
		return includeMap;
	}

    @Override
    public void close() throws IOException
    {
    }
}





import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;
import java.util.Map;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.dom.parser.c.GCCScannerExtensionConfiguration;

import org.eclipse.cdt.core.parser.NullLogService;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.core.parser.ScannerInfo;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;


     * @param includeSearchPaths - file paths to search in for included files
     * @throws IOException
     */
    public CppHelper(String filename, Reader in, String[] includeSearchPaths)
    		throws IOException
    {
    	//NOTE: it is important that the CodeReader gets an ABSOLUTE file path
        cpp = new CPreprocessor(new ReaderBasedCodeReader(filename, in),
            new ScannerInfo(null, includeSearchPaths), ParserLanguage.C,
            new NullLogService(), new GCCScannerExtensionConfiguration(),
            FileCodeReaderFactory.getInstance());

     *      Also, @param in could be different than @param file, if for example there
     *      are un-saved changes in the editor.
     */
    public CppHelper(IResource infoProvider, String filename, Reader in) throws IOException {
        //NOTE: it is important that the CodeReader gets an ABSOLUTE file path
        if (filename == null) 
            filename = "";

        }

        //Map<String, String> temp = scanInfo.getDefinedSymbols();
        cpp = new CPreprocessor(new ReaderBasedCodeReader(filename, in),
            new ScannerInfo(scanInfo.getDefinedSymbols(), scanInfo.getIncludePaths()), ParserLanguage.C, new NullLogService(), 
            new GCCScannerExtensionConfiguration(), FileCodeReaderFactory.getInstance());
    }




/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    UIUC - Initial API and implementation
 *******************************************************************************/
package org.eclipse.photran.internal.core.preprocessor.c;

import java.io.IOException;
import java.io.InputStream;

import org.eclipse.cdt.core.parser.CodeReader;

public class InputStreamCodeReader extends CodeReader 
{

	public InputStreamCodeReader(String filename, InputStream stream)
			throws IOException 
	{
		super(filename, convertToCharBuffer(stream));
		
		// TODO Auto-generated constructor stub
	}
	
	public InputStreamCodeReader(String filename, String charSet, InputStream stream)
			throws IOException 
	{
		//We are dropping out the charSet variable because it is used internally by 
		// CodeReader to read from the FileStream. Since we want to read from the 
		// InputStream, and we do it byte-wise, we don't really care for encoding
		super(filename, convertToCharBuffer(stream));
		// TODO Auto-generated constructor stub
	}
	
	private static char[] convertToCharBuffer(InputStream stream)
	{
		int b = 0;
		StringBuffer aggregate = new StringBuffer();
		while(b != -1)
		{
			try 
			{
				b = stream.read();
			} 
			catch (IOException e) 
			{
				e.printStackTrace();
				b = -1;
				break;
			}
			if(b != -1)
			{
				aggregate.append((char)b);
			}
		}
		return aggregate.toString().toCharArray();
	}

}




/*******************************************************************************
 * Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    UIUC - Initial API and implementation
 *           (Jeff Overbey) Modified to use Reader rather than InputStream
 *******************************************************************************/
package org.eclipse.photran.internal.core.preprocessor.c;

import java.io.IOException;
import java.io.Reader;

import org.eclipse.cdt.core.parser.CodeReader;

public class ReaderBasedCodeReader extends CodeReader 
{

	public ReaderBasedCodeReader(String filename, Reader stream)
			throws IOException 
	{
		super(filename, convertToCharBuffer(stream));
	}
	
	private static char[] convertToCharBuffer(Reader stream)
	{
		int b = 0;
		StringBuffer aggregate = new StringBuffer();
		while(b != -1)
		{
			try 
			{
				b = stream.read();
			} 
			catch (IOException e) 
			{
				e.printStackTrace();
				b = -1;
				break;
			}
			if(b != -1)
			{
				aggregate.append((char)b);
			}
		}
		try
        {
            stream.close();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
		return aggregate.toString().toCharArray();
	}
}

Lines 15-21 Link Here

(-)src/org/eclipse/photran/internal/core/tests/preprocessor/c/CppIntegratedSourceReproductionTestCase.java (-2 / +2 lines)
15	import java.io.FileNotFoundException;	15	import java.io.FileNotFoundException;
16	import java.io.FileReader;	16	import java.io.FileReader;
17	import java.io.IOException;	17	import java.io.IOException;
18	import java.io.InputStream;	18	import java.io.Reader;
19		19
20	import org.eclipse.photran.internal.core.lexer.CPreprocessedSourceForm;	20	import org.eclipse.photran.internal.core.lexer.CPreprocessedSourceForm;
21	import org.eclipse.photran.internal.core.lexer.SourceForm;	21	import org.eclipse.photran.internal.core.lexer.SourceForm;
Lines 35-41 Link Here
35	{	35	{
36	return new CPreprocessedSourceForm(new IncludeLoaderCallback(null)	36	return new CPreprocessedSourceForm(new IncludeLoaderCallback(null)
37	{	37	{
38	@Override public InputStream getIncludedFileAsStream(String fileToInclude) throws FileNotFoundException	38	@Override public Reader getIncludedFileAsStream(String fileToInclude) throws FileNotFoundException
39	{	39	{
40	throw new FileNotFoundException("#include lines not supported in JUnit tests");	40	throw new FileNotFoundException("#include lines not supported in JUnit tests");
41	}	41	}




 *******************************************************************************/
package org.eclipse.photran.internal.tests;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringReader;

import junit.framework.TestCase;


    protected <T extends IBodyConstruct> T parseStmt(String stmt) throws IOException, LexerException, SyntaxException
    {
        String program = stmt + "\nend program\n";
        ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(new StringReader(program), null, null, SourceForm.UNPREPROCESSED_FREE_FORM, true));
        ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(in, null, null, SourceForm.UNPREPROCESSED_FREE_FORM, true));
        assertTrue(ast != null);
        LoopReplacer.replaceAllLoopsIn(ast);
        return (T)((ASTMainProgramNode)ast.getProgramUnitList().get(0)).getBody().get(0);

Lines 10-16 Link Here

(-)src/org/eclipse/photran/internal/tests/analysis/types/TypeCheckerTestCase.java (-2 / +2 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.photran.internal.tests.analysis.types;	11	package org.eclipse.photran.internal.tests.analysis.types;
12		12
13	import java.io.ByteArrayInputStream;	13	import java.io.StringReader;
14		14
15	import junit.framework.TestCase;	15	import junit.framework.TestCase;
16		16
Lines 39-45 Link Here
39	// a parseable program, then extract the expression from the program's AST	39	// a parseable program, then extract the expression from the program's AST
40		40
41	String program = "a = " + expression + "\nend";	41	String program = "a = " + expression + "\nend";
42	ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(new ByteArrayInputStream(program.getBytes()), null, "<literal text>", SourceForm.UNPREPROCESSED_FREE_FORM, true /false/));	42	ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(new StringReader(program), null, "<literal text>", SourceForm.UNPREPROCESSED_FREE_FORM, true /false/));
43	assertNotNull(ast);	43	assertNotNull(ast);
44	ASTMainProgramNode mainProg = (ASTMainProgramNode)ast.getProgramUnitList().get(0);	44	ASTMainProgramNode mainProg = (ASTMainProgramNode)ast.getProgramUnitList().get(0);
45	ASTAssignmentStmtNode assignmentStmt = (ASTAssignmentStmtNode)mainProg.getBody().get(0);	45	ASTAssignmentStmtNode assignmentStmt = (ASTAssignmentStmtNode)mainProg.getBody().get(0);




 *******************************************************************************/
package org.eclipse.photran.internal.tests.parser;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;


    
    private ASTExecutableProgramNode parse(SourceForm sourceForm, String string) throws IOException, LexerException, SyntaxException
    {
        ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(new StringReader(string), null, "<stdin>", sourceForm, true));
        ASTExecutableProgramNode ast = new Parser().parse(LexerFactory.createLexer(in, null, "<stdin>", sourceForm, true));
        assertTrue(ast != null);
        return ast;
    }

Lines 1-6 Link Here

(-)src/org/eclipse/photran/internal/ui/editor_vpg/FortranEditorTasks.java (-2 / +2 lines)
1	package org.eclipse.photran.internal.ui.editor_vpg;	1	package org.eclipse.photran.internal.ui.editor_vpg;
2		2
3	import java.io.ByteArrayInputStream;	3	import java.io.StringReader;
4	import java.util.HashSet;	4	import java.util.HashSet;
5	import java.util.Set;	5	import java.util.Set;
6		6
Lines 179-185 Link Here
179	String editorContents = editor.getDocumentProvider().getDocument(editor.getEditorInput()).get();	179	String editorContents = editor.getDocumentProvider().getDocument(editor.getEditorInput()).get();
180		180
181	SourceForm sourceForm = determineSourceForm();	181	SourceForm sourceForm = determineSourceForm();
182	IAccumulatingLexer lexer = LexerFactory.createLexer(new ByteArrayInputStream(editorContents.getBytes()),	182	IAccumulatingLexer lexer = LexerFactory.createLexer(new StringReader(editorContents),
183	editor.getIFile(),	183	editor.getIFile(),
184	editor.getIFile().getName(),	184	editor.getIFile().getName(),
185	sourceForm,	185	sourceForm,




import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.Reader;
import java.io.StringReader;
import java.lang.reflect.InvocationTargetException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.text.IDocument;
import org.eclipse.photran.internal.core.lexer.CPreprocessingReader;
import org.eclipse.photran.internal.ui.editor.FixedFormFortranEditor;
import org.eclipse.photran.internal.ui.editor.FreeFormFortranEditor;
import org.eclipse.ui.ide.IDE;

 *
 * @author Jeff Overbey
 */
@SuppressWarnings({ "restriction" })
public class DisplayPreprocessedSource extends FortranEditorActionDelegate
{
    public void run(IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException

        	boolean isFixedForm = getFortranEditor().isFixedForm();
        	
            IDocument doc = getFortranEditor().getIDocument();
            Reader in = new StringReader(doc.get());
            Reader cppIn = new CPreprocessingReader(getFortranEditor().getIFile(), null, in);
            
            File tempFile = File.createTempFile(
            	"tmp",

Lines 67-73 Link Here

(-)src/org/eclipse/rephraserengine/core/util/StringUtil.java (-1 / +1 lines)
67		67
68	public static String read(IFile file) throws IOException, CoreException	68	public static String read(IFile file) throws IOException, CoreException
69	{	69	{
70	return read(file.getContents(true));	70	return read(new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset())));
71	}	71	}
72		72
73	public static String read(File file) throws IOException	73	public static String read(File file) throws IOException




package org.eclipse.rephraserengine.core.vpg.refactoring;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;

        return ast.toString();
    }

    private int getSizeOf(IFile file) throws CoreException, IOException
    {
        int size = 0;
        Reader in = new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset()));
        while (in.read() > -1)
            size++;
        in.close();

Lines 10-17 Link Here

(-)src/org/eclipse/rephraserengine/internal/examples/text/ConvertTabsToSpacesRefactoring.java (-2 / +4 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.rephraserengine.internal.examples.text;	11	package org.eclipse.rephraserengine.internal.examples.text;
12		12
13	import java.io.BufferedInputStream;	13	import java.io.BufferedReader;
14	import java.io.IOException;	14	import java.io.IOException;
		15	import java.io.InputStreamReader;
		16	import java.io.Reader;
15	import java.util.List;	17	import java.util.List;
16		18
17	import org.eclipse.core.resources.IFile;	19	import org.eclipse.core.resources.IFile;
Lines 127-133 Link Here
127	TextFileChange change = new TextFileChange("Replace tabs in " + file.getName(), file);	129	TextFileChange change = new TextFileChange("Replace tabs in " + file.getName(), file);
128	change.setEdit(new MultiTextEdit());	130	change.setEdit(new MultiTextEdit());
129		131
130	BufferedInputStream in = new BufferedInputStream(file.getContents(true));	132	Reader in = new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset()));
131	int offset = 0;	133	int offset = 0;
132	int column = 0;	134	int column = 0;
133	int numberOfTabsReplaced = 0;	135	int numberOfTabsReplaced = 0;





import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.Reader;
import java.util.ArrayList;

import org.eclipse.core.runtime.NullProgressMonitor;

                if (filename != null)
                {
                    ArrayList<Integer> lineMap = new ArrayList<Integer>();
                    String fileContents = readStream(lineMap,
                        new BufferedReader(new InputStreamReader(info.getFileInEditor().getContents(true), info.getFileInEditor().getCharset())));
                    ps.println(filename);
                    ps.println();
                    Model model = new Model("edge model", new NullProgressMonitor(), 0, vpg, filename);

        }
    }

    protected String readStream(ArrayList<Integer> lineMap, Reader in) throws IOException
    {
        StringBuffer sb = new StringBuffer(4096);
        BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
        for (int offset = 0, ch = in.read(); ch >= 0; ch = in.read())
        {
            sb.append((char)ch);

Return to bug 312249

Lines 34-40 Link Here

(-)lexer/FixedFormLexerPhase1.flex (-4 / +4 lines)
34	package org.eclipse.photran.internal.core.lexer;	34	package org.eclipse.photran.internal.core.lexer;
35		35
36	import java.util.regex.Pattern;	36	import java.util.regex.Pattern;
37	import java.io.InputStream;	37	import java.io.Reader;
38	import org.eclipse.core.resources.IFile;	38	import org.eclipse.core.resources.IFile;
39		39
40	@SuppressWarnings("unused")	40	@SuppressWarnings("unused")
Lines 58-65 Link Here
58		58
59	private TokenFactory tokenFactory;	59	private TokenFactory tokenFactory;
60		60
61	public FixedFormLexerPhase1(InputStream in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {	61	public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {
62	this(new LineAppendingInputStream(in));	62	this(new LineAppendingReader(in));
63	this.prepass=_prepass;	63	this.prepass=_prepass;
64	this.tokenFactory = tokenFactory;	64	this.tokenFactory = tokenFactory;
65	}	65	}
Lines 188-194 Link Here
188		188
189	private String filename = "<stdin>";	189	private String filename = "<stdin>";
190		190
191	public FixedFormLexerPhase1(java.io.InputStream in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)	191	public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)
192	{	192	{
193	this(in, _prepass, tokenFactory);	193	this(in, _prepass, tokenFactory);
194	this.lastTokenFile = new FileOrIFile(file);	194	this.lastTokenFile = new FileOrIFile(file);

Lines 27-34 Link Here

(-)lexer/FreeFormLexerPhase1.flex (-2 / +4 lines)
27	*/	27	*/
28		28
29	package org.eclipse.photran.internal.core.lexer;	29	package org.eclipse.photran.internal.core.lexer;
		30
30	import java.io.FileNotFoundException;	31	import java.io.FileNotFoundException;
31	import java.io.IOException;	32	import java.io.IOException;
		33	import java.io.Reader;
32	import org.eclipse.core.resources.IFile;	34	import org.eclipse.core.resources.IFile;
33		35
34	@SuppressWarnings("unused")	36	@SuppressWarnings("unused")
Lines 120-128 Link Here
120	private String filename = "<stdin>";	122	private String filename = "<stdin>";
121	protected TokenFactory tokenFactory;	123	protected TokenFactory tokenFactory;
122		124
123	public FreeFormLexerPhase1(java.io.InputStream in, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)	125	public FreeFormLexerPhase1(Reader in, IFile file, String filename, TokenFactory tokenFactory, boolean accumulateWhitetext)
124	{	126	{
125	this(new LineAppendingInputStream(in));	127	this(new LineAppendingReader(in));
126	this.lastTokenFile = new FileOrIFile(file);	128	this.lastTokenFile = new FileOrIFile(file);
127	this.filename = filename;	129	this.filename = filename;
128	this.tokenFactory = tokenFactory;	130	this.tokenFactory = tokenFactory;

Lines 1-4 Link Here

(-)lexer/org/eclipse/photran/internal/core/lexer/FixedFormLexerPhase1.java (-6 / +6 lines)
1	/* The following code was generated by JFlex 1.4.1 on 3/18/10 4:23 PM */	1	/* The following code was generated by JFlex 1.4.1 on 5/11/10 8:56 PM */
2		2
3	/*******************************************************************************	3	/*******************************************************************************
4	* Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.	4	* Copyright (c) 2009 University of Illinois at Urbana-Champaign and others.
Lines 36-42 Link Here
36	package org.eclipse.photran.internal.core.lexer;	36	package org.eclipse.photran.internal.core.lexer;
37		37
38	import java.util.regex.Pattern;	38	import java.util.regex.Pattern;
39	import java.io.InputStream;	39	import java.io.Reader;
40	import org.eclipse.core.resources.IFile;	40	import org.eclipse.core.resources.IFile;
41		41
42	@SuppressWarnings("unused")	42	@SuppressWarnings("unused")
Lines 44-50 Link Here
44	/**	44	/**
45	* This class is a scanner generated by	45	* This class is a scanner generated by
46	* <a href="http://www.jflex.de/">JFlex</a> 1.4.1	46	* <a href="http://www.jflex.de/">JFlex</a> 1.4.1
47	* on 3/18/10 4:23 PM from the specification file	47	* on 5/11/10 8:56 PM from the specification file
48	* <tt>FixedFormLexerPhase1.flex</tt>	48	* <tt>FixedFormLexerPhase1.flex</tt>
49	*/	49	*/
50	class FixedFormLexerPhase1 implements ILexer {	50	class FixedFormLexerPhase1 implements ILexer {
Lines 916-923 Link Here
916		916
917	private TokenFactory tokenFactory;	917	private TokenFactory tokenFactory;
918		918
919	public FixedFormLexerPhase1(InputStream in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {	919	public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, TokenFactory tokenFactory) {
920	this(new LineAppendingInputStream(in));	920	this(new LineAppendingReader(in));
921	this.prepass=_prepass;	921	this.prepass=_prepass;
922	this.tokenFactory = tokenFactory;	922	this.tokenFactory = tokenFactory;
923	}	923	}
Lines 1046-1052 Link Here
1046		1046
1047	private String filename = "<stdin>";	1047	private String filename = "<stdin>";
1048		1048
1049	public FixedFormLexerPhase1(java.io.InputStream in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)	1049	public FixedFormLexerPhase1(Reader in, FixedFormLexerPrepass _prepass, IFile file, String filename, TokenFactory tokenFactory)
1050	{	1050	{
1051	this(in, _prepass, tokenFactory);	1051	this(in, _prepass, tokenFactory);
1052	this.lastTokenFile = new FileOrIFile(file);	1052	this.lastTokenFile = new FileOrIFile(file);

Lines 36-41 Link Here

(-)lexer/org/eclipse/photran/internal/core/lexer/LineAppendingInputStream.java (-1 / +2 lines)
36	this.currentInputStream = originalInputStream;	36	this.currentInputStream = originalInputStream;
37	}	37	}
38		38
		39	@Override
39	public int read() throws IOException	40	public int read() throws IOException
40	{	41	{
41	int result = currentInputStream.read();	42	int result = currentInputStream.read();
Lines 44-50 Link Here
44	{	45	{
45	currentInputStream = eolInputStream;	46	currentInputStream = eolInputStream;
46	result = currentInputStream.read();	47	result = currentInputStream.read();
47	currentInputStream.available();
48	}	48	}
49	else	49	else
50	{	50	{
Lines 64-69 Link Here
64	private static final byte[] EOL = System.getProperty("line.separator").getBytes();	64	private static final byte[] EOL = System.getProperty("line.separator").getBytes();
65	private int eolByte = 0;	65	private int eolByte = 0;
66		66
		67	@Override
67	public int read() throws IOException	68	public int read() throws IOException
68	{	69	{
69	return eolByte < EOL.length ? EOL[eolByte++] : -1;	70	return eolByte < EOL.length ? EOL[eolByte++] : -1;

Added Link Here

(-)lexer/org/eclipse/photran/internal/core/lexer/LineAppendingReader.java (+84 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 University of Illinois at Urbana-Champaign and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* UIUC - Initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.photran.internal.core.lexer;
12
13	import java.io.IOException;
14	import java.io.Reader;
15
16	/**
17	* Wraps another <code>Reader</code>, and, if the wrapped stream does not end
18	* with an end-of-line character, appends the OS-dependent end-of-line sequence to
19	* the end of the stream.
20	*
21	* @author Jeff Overbey
22	*/
23	public final class LineAppendingReader extends SingleCharReader
24	{
25	private Reader originalReader;
26	private Reader eolReader;
27	private Reader currentReader;
28
29	private int lastChar = -1;
30
31	public LineAppendingReader(Reader streamToWrap)
32	{
33	this.originalReader = streamToWrap;
34	this.eolReader = new EOLReader();
35
36	this.currentReader = originalReader;
37	}
38
39	@Override
40	public int read() throws IOException
41	{
42	int result = currentReader.read();
43
44	if (result == -1 && currentReader == originalReader && !isEOL(lastChar))
45	{
46	currentReader = eolReader;
47	result = currentReader.read();
48	}
49	else
50	{
51	lastChar = result;
52	}
53
54	return result;
55	}
56
57	private boolean isEOL(int c)
58	{
59	return c =='\n' \|\| c == '\r';
60	}
61
62	@Override
63	public void close() throws IOException
64	{
65	originalReader.close();
66	}
67
68	private static class EOLReader extends SingleCharReader
69	{
70	private static final byte[] EOL = System.getProperty("line.separator").getBytes();
71	private int eolByte = 0;
72
73	@Override
74	public int read() throws IOException
75	{
76	return eolByte < EOL.length ? EOL[eolByte++] : -1;
77	}
78
79	@Override
80	public void close() throws IOException
81	{
82	}
83	}
84	}

Added Link Here

(-)lexer/org/eclipse/photran/internal/core/lexer/SingleCharReader.java (+66 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.photran.internal.core.lexer;
12
13	import java.io.IOException;
14	import java.io.Reader;
15
16
17	/**
18	* Copied from org.eclipse.jface.internal.text.html.SingleCharReader
19	* <p>
20	* Moved into this package from <code>org.eclipse.jface.internal.text.revisions</code>.</p>
21	*/
22	public abstract class SingleCharReader extends Reader {
23
24	/**
25	* @see Reader#read()
26	*/
27	public abstract int read() throws IOException;
28
29	/**
30	* @see Reader#read(char[],int,int)
31	*/
32	public int read(char cbuf[], int off, int len) throws IOException {
33	int end= off + len;
34	for (int i= off; i < end; i++) {
35	int ch= read();
36	if (ch == -1) {
37	if (i == off)
38	return -1;
39	return i - off;
40	}
41	cbuf[i]= (char)ch;
42	}
43	return len;
44	}
45
46	/**
47	* @see Reader#ready()
48	*/
49	public boolean ready() throws IOException {
50	return true;
51	}
52
53	/**
54	* Returns the readable content as string.
55	* @return the readable content as string
56	* @exception IOException in case reading fails
57	*/
58	public String getString() throws IOException {
59	StringBuffer buf= new StringBuffer();
60	int ch;
61	while ((ch= read()) != -1) {
62	buf.append((char)ch);
63	}
64	return buf.toString();
65	}
66	}

Lines 12-20 Link Here

(-)src/org/eclipse/photran/internal/core/preprocessor/c/CppHelper.java (-7 / +5 lines)
12		12
13	import java.io.File;	13	import java.io.File;
14	import java.io.IOException;	14	import java.io.IOException;
15	import java.io.InputStream;	15	import java.io.Reader;
16	import java.util.Arrays;	16	import java.util.Arrays;
17	import java.util.Map;
18		17
19	import org.eclipse.cdt.core.CCorePlugin;	18	import org.eclipse.cdt.core.CCorePlugin;
20	import org.eclipse.cdt.core.dom.parser.c.GCCScannerExtensionConfiguration;	19	import org.eclipse.cdt.core.dom.parser.c.GCCScannerExtensionConfiguration;
Lines 24-30 Link Here
24	import org.eclipse.cdt.core.parser.NullLogService;	23	import org.eclipse.cdt.core.parser.NullLogService;
25	import org.eclipse.cdt.core.parser.ParserLanguage;	24	import org.eclipse.cdt.core.parser.ParserLanguage;
26	import org.eclipse.cdt.core.parser.ScannerInfo;	25	import org.eclipse.cdt.core.parser.ScannerInfo;
27	import org.eclipse.core.resources.IFile;
28	import org.eclipse.core.resources.IProject;	26	import org.eclipse.core.resources.IProject;
29	import org.eclipse.core.resources.IResource;	27	import org.eclipse.core.resources.IResource;
30		28
Lines 64-74 Link Here
64	* @param includeSearchPaths - file paths to search in for included files	62	* @param includeSearchPaths - file paths to search in for included files
65	* @throws IOException	63	* @throws IOException
66	*/	64	*/
67	public CppHelper(String filename, InputStream in, String[] includeSearchPaths)	65	public CppHelper(String filename, Reader in, String[] includeSearchPaths)
68	throws IOException	66	throws IOException
69	{	67	{
70	//NOTE: it is important that the CodeReader gets an ABSOLUTE file path	68	//NOTE: it is important that the CodeReader gets an ABSOLUTE file path
71	cpp = new CPreprocessor(new InputStreamCodeReader(filename, in),	69	cpp = new CPreprocessor(new ReaderBasedCodeReader(filename, in),
72	new ScannerInfo(null, includeSearchPaths), ParserLanguage.C,	70	new ScannerInfo(null, includeSearchPaths), ParserLanguage.C,
73	new NullLogService(), new GCCScannerExtensionConfiguration(),	71	new NullLogService(), new GCCScannerExtensionConfiguration(),
74	FileCodeReaderFactory.getInstance());	72	FileCodeReaderFactory.getInstance());
Lines 85-91 Link Here
85	* Also, @param in could be different than @param file, if for example there	83	* Also, @param in could be different than @param file, if for example there
86	* are un-saved changes in the editor.	84	* are un-saved changes in the editor.
87	*/	85	*/
88	public CppHelper(IResource infoProvider, String filename, InputStream in) throws IOException {	86	public CppHelper(IResource infoProvider, String filename, Reader in) throws IOException {
89	//NOTE: it is important that the CodeReader gets an ABSOLUTE file path	87	//NOTE: it is important that the CodeReader gets an ABSOLUTE file path
90	if (filename == null)	88	if (filename == null)
91	filename = "";	89	filename = "";
Lines 104-110 Link Here
104	}	102	}
105		103
106	//Map<String, String> temp = scanInfo.getDefinedSymbols();	104	//Map<String, String> temp = scanInfo.getDefinedSymbols();
107	cpp = new CPreprocessor(new InputStreamCodeReader(filename, in),	105	cpp = new CPreprocessor(new ReaderBasedCodeReader(filename, in),
108	new ScannerInfo(scanInfo.getDefinedSymbols(), scanInfo.getIncludePaths()), ParserLanguage.C, new NullLogService(),	106	new ScannerInfo(scanInfo.getDefinedSymbols(), scanInfo.getIncludePaths()), ParserLanguage.C, new NullLogService(),
109	new GCCScannerExtensionConfiguration(), FileCodeReaderFactory.getInstance());	107	new GCCScannerExtensionConfiguration(), FileCodeReaderFactory.getInstance());
110	}	108	}

Lines 13-27 Link Here

(-)src/org/eclipse/photran/internal/ui/actions/DisplayPreprocessedSource.java (-6 / +6 lines)
13	import java.io.BufferedOutputStream;	13	import java.io.BufferedOutputStream;
14	import java.io.File;	14	import java.io.File;
15	import java.io.FileOutputStream;	15	import java.io.FileOutputStream;
16	import java.io.InputStream;
17	import java.io.PrintStream;	16	import java.io.PrintStream;
18	import java.io.StringBufferInputStream;	17	import java.io.Reader;
		18	import java.io.StringReader;
19	import java.lang.reflect.InvocationTargetException;	19	import java.lang.reflect.InvocationTargetException;
20		20
21	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
22	import org.eclipse.jface.dialogs.MessageDialog;	22	import org.eclipse.jface.dialogs.MessageDialog;
23	import org.eclipse.jface.text.IDocument;	23	import org.eclipse.jface.text.IDocument;
24	import org.eclipse.photran.internal.core.lexer.CPreprocessingInputStream;	24	import org.eclipse.photran.internal.core.lexer.CPreprocessingReader;
25	import org.eclipse.photran.internal.ui.editor.FixedFormFortranEditor;	25	import org.eclipse.photran.internal.ui.editor.FixedFormFortranEditor;
26	import org.eclipse.photran.internal.ui.editor.FreeFormFortranEditor;	26	import org.eclipse.photran.internal.ui.editor.FreeFormFortranEditor;
27	import org.eclipse.ui.ide.IDE;	27	import org.eclipse.ui.ide.IDE;
Lines 32-38 Link Here
32	*	32	*
33	* @author Jeff Overbey	33	* @author Jeff Overbey
34	*/	34	*/
35	@SuppressWarnings({ "deprecation", "restriction" })	35	@SuppressWarnings({ "restriction" })
36	public class DisplayPreprocessedSource extends FortranEditorActionDelegate	36	public class DisplayPreprocessedSource extends FortranEditorActionDelegate
37	{	37	{
38	public void run(IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException	38	public void run(IProgressMonitor progressMonitor) throws InvocationTargetException, InterruptedException
Lines 42-49 Link Here
42	boolean isFixedForm = getFortranEditor().isFixedForm();	42	boolean isFixedForm = getFortranEditor().isFixedForm();
43		43
44	IDocument doc = getFortranEditor().getIDocument();	44	IDocument doc = getFortranEditor().getIDocument();
45	InputStream in = new StringBufferInputStream(doc.get());	45	Reader in = new StringReader(doc.get());
46	InputStream cppIn = new CPreprocessingInputStream(getFortranEditor().getIFile(), null, in);	46	Reader cppIn = new CPreprocessingReader(getFortranEditor().getIFile(), null, in);
47		47
48	File tempFile = File.createTempFile(	48	File tempFile = File.createTempFile(
49	"tmp",	49	"tmp",

Lines 1-7 Link Here

(-)src/org/eclipse/rephraserengine/core/vpg/refactoring/VPGRefactoring.java (-3 / +6 lines)
1	package org.eclipse.rephraserengine.core.vpg.refactoring;	1	package org.eclipse.rephraserengine.core.vpg.refactoring;
2		2
		3	import java.io.BufferedReader;
3	import java.io.IOException;	4	import java.io.IOException;
4	import java.io.InputStream;	5	import java.io.InputStreamReader;
		6	import java.io.Reader;
5		7
6	import org.eclipse.core.resources.IFile;	8	import org.eclipse.core.resources.IFile;
7	import org.eclipse.core.runtime.CoreException;	9	import org.eclipse.core.runtime.CoreException;
Lines 237-245 Link Here
237	return ast.toString();	239	return ast.toString();
238	}	240	}
239		241
240	private int getSizeOf(IFile file) throws CoreException, IOException {	242	private int getSizeOf(IFile file) throws CoreException, IOException
		243	{
241	int size = 0;	244	int size = 0;
242	InputStream in = file.getContents(true);	245	Reader in = new BufferedReader(new InputStreamReader(file.getContents(true), file.getCharset()));
243	while (in.read() > -1)	246	while (in.read() > -1)
244	size++;	247	size++;
245	in.close();	248	in.close();