Attachment #146215 for bug #242153

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 14-20 Link Here

(-)src/org/eclipse/qvt/declarative/parser/AbstractQVTAnalyzer.java (-1 / +1 lines)
14	import java.util.Comparator;	14	import java.util.Comparator;
15	import java.util.List;	15	import java.util.List;
16		16
17	import lpg.lpgjavaruntime.Monitor;	17	import lpg.runtime.Monitor;
18		18
19	import org.eclipse.emf.common.util.EList;	19	import org.eclipse.emf.common.util.EList;
20	import org.eclipse.emf.ecore.EClass;	20	import org.eclipse.emf.ecore.EClass;

Lines 266-272 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/CSTRootEnvironment.java (-1 / +1 lines)
266	}	266	}
267		267
268	public int getCSTErrorTokens() {	268	public int getCSTErrorTokens() {
269	return getParser().getErrorTokens();	269	return getParser().getIPrsStream().getErrorTokens();
270	}	270	}
271		271
272	public ICSTFileEnvironment getFileEnvironment() {	272	public ICSTFileEnvironment getFileEnvironment() {

Lines 20-26 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/ICSTFileEnvironment.java (-2 / +2 lines)
20	import java.io.Reader;	20	import java.io.Reader;
21	import java.util.Collection;	21	import java.util.Collection;
22		22
23	import lpg.lpgjavaruntime.Monitor;	23	import lpg.runtime.Monitor;
24		24
25	import org.eclipse.core.runtime.CoreException;	25	import org.eclipse.core.runtime.CoreException;
26	import org.eclipse.core.runtime.IProgressMonitor;	26	import org.eclipse.core.runtime.IProgressMonitor;
Lines 34-40 Link Here
34		34
35	public interface ICSTFileEnvironment extends ICSTEnvironment	35	public interface ICSTFileEnvironment extends ICSTEnvironment
36	{	36	{
37	public ICSTFileAnalyzer<?> createAnalyzer(Monitor monitor);	37	public ICSTFileAnalyzer<?> getAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException;
38		38
39	public XMIResource getASTResource();	39	public XMIResource getASTResource();
40		40

Lines 31-37 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/ICSTFileAnalyzer.java (+7 lines)
31		31
32	public AbstractParser getParser();	32	public AbstractParser getParser();
33		33
		34	/**
		35	* @param reader
		36	* @throws IOException
		37	* @deprecated clients should invoke {@link #reset(Reader, String)}
		38	*/
34	public void initialize(Reader reader) throws IOException;	39	public void initialize(Reader reader) throws IOException;
		40
		41	public void reset(Reader reader, String fileName) throws IOException;
35		42
36	public void setFileName(String name);	43	public void setFileName(String name);
37	}	44	}

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/CSTFileEnvironment.java (-8 / +22 lines)
16	import java.util.ArrayList;	16	import java.util.ArrayList;
17	import java.util.List;	17	import java.util.List;
18		18
19	import lpg.lpgjavaruntime.Monitor;	19	import lpg.runtime.Monitor;
20		20
21	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
Lines 42-48 Link Here
42	{	42	{
43	protected final EPackage.Registry registryToo;	43	protected final EPackage.Registry registryToo;
44	protected final XMIResource ast;	44	protected final XMIResource ast;
45	protected final AbstractModelResolver resolver;	45	protected final AbstractModelResolver resolver;
		46
		47	private ICSTFileAnalyzer<R> analyzer;
		48
46	private TypeResolver<EClassifier, EOperation, EStructuralFeature> typeResolver; // FIXME Duplicated to support reset	49	private TypeResolver<EClassifier, EOperation, EStructuralFeature> typeResolver; // FIXME Duplicated to support reset
47	// inherited functionality should allow typeResolver to be in CSTRootEnvironment	50	// inherited functionality should allow typeResolver to be in CSTRootEnvironment
48		51
Lines 63-69 Link Here
63	this(new EPackageRegistryImpl(), file, resourceSet, astResource);	66	this(new EPackageRegistryImpl(), file, resourceSet, astResource);
64	}	67	}
65		68
66	public abstract ICSTFileAnalyzer<R> createAnalyzer(Monitor monitor);	69	public ICSTFileAnalyzer<R> getAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException {
		70
		71	if (analyzer == null) {
		72	analyzer = createAnalyzer(monitor, reader, fileName);
		73	} else {
		74	analyzer.reset(reader, null);
		75	}
		76	return analyzer;
		77	}
		78
		79	protected abstract ICSTFileAnalyzer<R> createAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException;
67		80
68	protected abstract R createRootEnvironment(XMIResource ast, CST cst);	81	protected abstract R createRootEnvironment(XMIResource ast, CST cst);
69		82
Lines 110-134 Link Here
110		123
111	public ICSTRootEnvironment parse(Reader reader, AbstractFileHandle file, IProgressMonitor monitor) throws IOException, CoreException {	124	public ICSTRootEnvironment parse(Reader reader, AbstractFileHandle file, IProgressMonitor monitor) throws IOException, CoreException {
112	Monitor lpgMonitor = new LPGProgressMonitor(monitor);	125	Monitor lpgMonitor = new LPGProgressMonitor(monitor);
113	ICSTFileAnalyzer<R> analyzer = createAnalyzer(lpgMonitor);
114	analyzer.setFileName(file.getName());
115	if (reader == null)	126	if (reader == null)
116	reader = new InputStreamReader(file.getContents());	127	reader = new InputStreamReader(file.getContents());
117	else if (!file.exists())	128	else if (!file.exists())
118	return null;	129	return null;
119	analyzer.initialize(reader);	130
		131	ICSTFileAnalyzer<R> analyzer = getAnalyzer(lpgMonitor, reader, file.getName());
		132	// analyzer.initialize(reader);
120	AbstractParser parser = getParser();	133	AbstractParser parser = getParser();
121	if ((monitor != null) && monitor.isCanceled())	134	if ((monitor != null) && monitor.isCanceled())
122	return null;	135	return null;
123	parser.getLexer().lexToTokens(parser);	136	parser.getLexer().lexer(parser.getIPrsStream());
124	if ((monitor != null) && monitor.isCanceled())	137	if ((monitor != null) && monitor.isCanceled())
125	return null;	138	return null;
126	@SuppressWarnings("unchecked") // Maybe this should be a generic parameter	139	@SuppressWarnings("unchecked") // Maybe this should be a generic parameter
127	CST cst = (CST) parser.parseTokensToCST(lpgMonitor, -1);	140	CST cst = (CST) parser.parser(lpgMonitor, -1);
128	if (cst == null)	141	if (cst == null)
129	return null;	142	return null;
130	if ((monitor != null) && monitor.isCanceled())	143	if ((monitor != null) && monitor.isCanceled())
131	return null;	144	return null;
		145
132	R rootEnvironment;	146	R rootEnvironment;
133	try {	147	try {
134	reset();	148	reset();

Lines 10-16 Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvt/environment/LPGProgressMonitor.java (-1 / +1 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.qvt.declarative.parser.qvt.environment;	11	package org.eclipse.qvt.declarative.parser.qvt.environment;
12		12
13	import lpg.lpgjavaruntime.Monitor;	13	import lpg.runtime.Monitor;
14		14
15	import org.eclipse.core.runtime.IProgressMonitor;	15	import org.eclipse.core.runtime.IProgressMonitor;
16		16




import java.util.Map;
import java.util.Set;

import lpg.runtime.IPrsStream;

import org.eclipse.ocl.lpg.AbstractProblemHandler;
import org.eclipse.ocl.lpg.ProblemHandler;
import org.eclipse.osgi.util.NLS;

						if (problem.endOffset >= 0) {
							s.append(" : ");
							s.append(problem.endOffset);
							IPrsStream stream = getParser().getIPrsStream();
							if (stream != null) {
								int token =stream.getTokenIndexAtCharacter(problem.startOffset);
								s.append(" ");
								try {
									s.append(stream.getLine(token));
								} catch (ArrayIndexOutOfBoundsException e) {
									s.append("???");
								}
								s.append(":");
								try {
									s.append(stream.getColumn(token));
								} catch (ArrayIndexOutOfBoundsException e) {
									s.append("???");
								}

Lines 18-25 Link Here

(-)META-INF/MANIFEST.MF (-2 / +2 lines)
18	org.eclipse.qvt.declarative.parser.utils	18	org.eclipse.qvt.declarative.parser.utils
19	Require-Bundle: org.eclipse.core.runtime,	19	Require-Bundle: org.eclipse.core.runtime,
20	org.eclipse.emf.ecore;visibility:=reexport,	20	org.eclipse.emf.ecore;visibility:=reexport,
21	org.eclipse.ocl;bundle-version="[1.3.0,2.0.0)";visibility:=reexport,	21	org.eclipse.ocl;bundle-version="[3.0.0,4.0.0)";visibility:=reexport,
22	org.eclipse.ocl.ecore;visibility:=reexport,	22	org.eclipse.ocl.ecore;bundle-version="[3.0.0,4.0.0)";visibility:=reexport,
23	org.eclipse.qvt.declarative.ecore.qvtbase;visibility:=reexport,	23	org.eclipse.qvt.declarative.ecore.qvtbase;visibility:=reexport,
24	org.eclipse.qvt.declarative.parser.unresolved;resolution:=optional,	24	org.eclipse.qvt.declarative.parser.unresolved;resolution:=optional,
25	org.eclipse.qvt.declarative.modelregistry;visibility:=reexport	25	org.eclipse.qvt.declarative.modelregistry;visibility:=reexport




package org.eclipse.qvt.declarative.editor.ocl.ui.imp;

import org.eclipse.ocl.cst.CSTPackage;
import org.eclipse.ocl.parser.backtracking.OCLBacktrackingParsersym;
import org.eclipse.qvt.declarative.editor.ocl.ui.OCLCreationFactory;
import org.eclipse.qvt.declarative.editor.ui.imp.CommonKeyword;
import org.eclipse.qvt.declarative.editor.ui.imp.CommonParseController;


	public TokenKind getTokenKind(int kind) {
		switch (kind) {
		case OCLBacktrackingParsersym.TK_EOF_TOKEN:
			return TokenKind.EOF;
		case OCLBacktrackingParsersym.TK_IDENTIFIER:
			return TokenKind.IDENTIFIER;
		case OCLBacktrackingParsersym.TK_INTEGER_LITERAL:
			return TokenKind.INTEGER;
		case OCLBacktrackingParsersym.TK_REAL_LITERAL:
			return TokenKind.REAL;
        case OCLBacktrackingParsersym.TK_STRING_LITERAL:
            return TokenKind.STRING;
        case OCLBacktrackingParsersym.TK_SINGLE_LINE_COMMENT:
            return TokenKind.LINE_COMMENT;
        case OCLBacktrackingParsersym.TK_MULTI_LINE_COMMENT:
            return TokenKind.PARAGRAPH_COMMENT;
		default:
			if (isKeyword(kind))

Lines 16-25 Link Here

(-)src/org/eclipse/qvt/declarative/parser/ocl/OCLFileAnalyzer.java (-3 / +5 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.parser.ocl;	17	package org.eclipse.qvt.declarative.parser.ocl;
18		18
		19	import java.io.IOException;
		20	import java.io.Reader;
19	import java.util.ArrayList;	21	import java.util.ArrayList;
20	import java.util.List;	22	import java.util.List;
21		23
22	import lpg.lpgjavaruntime.Monitor;	24	import lpg.runtime.Monitor;
23		25
24	import org.eclipse.emf.ecore.EClass;	26	import org.eclipse.emf.ecore.EClass;
25	import org.eclipse.emf.ecore.EClassifier;	27	import org.eclipse.emf.ecore.EClassifier;
Lines 52-59 Link Here
52	private OCLTopLevelEnvironment topLevelEnvironment = null;	54	private OCLTopLevelEnvironment topLevelEnvironment = null;
53	private EClass iteratorsClass = null;	55	private EClass iteratorsClass = null;
54		56
55	public OCLFileAnalyzer(OCLFileEnvironment environment, Monitor monitor) {	57	public OCLFileAnalyzer(OCLFileEnvironment environment, Monitor monitor, Reader reader, String fileName) throws IOException {
56	super(new OCLBacktrackingParser(new OCLBacktrackingLexer(environment)));	58	super(new OCLBacktrackingParser(new OCLBacktrackingLexer(environment, reader, fileName)));
57	this.monitor = monitor;	59	this.monitor = monitor;
58	}	60	}
59		61




 */
package org.eclipse.qvt.declarative.parser.ocl.environment;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import lpg.runtime.IToken;
import lpg.runtime.Monitor;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EClass;

	}

	@Override
	protected OCLFileAnalyzer createAnalyzer(
			Monitor monitor, Reader reader, String fileName) throws IOException {
		return new OCLFileAnalyzer(this, monitor, reader, fileName);
	}

	@Override




import java.util.Iterator;
import java.util.List;

import lpg.runtime.ErrorToken;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;


	static final class TokenIterator implements Iterator<IToken>
	{
		final IPrsStream stream;
		final int firstTokIdx;
		final int lastTokIdx;
		int curTokIdx; // skip bogus initial token

		private boolean finalTokenReturned;
		private boolean finalAdjunctsReturned;

		private TokenIterator(IPrsStream stream, int regionEnd, int regionOffset) {
			this.stream = stream;
			firstTokIdx = getTokenIndexAtCharacter(regionOffset);
			curTokIdx = Math.max(1, firstTokIdx);

	}

	public String getTextRange(int start, int length) {
		return new String(getLexer().getILexStream().getInputChars(), start, length);
	}

	protected int[] getKeywordKinds() {

        int regionOffset= region.getOffset();
        int regionLength= region.getLength();
    	int regionEnd = regionOffset + regionLength - 1;
		IPrsStream stream =  getParser().getIPrsStream();
		if (stream != null)
			return new TokenIterator(stream, regionEnd, regionOffset);
		else




import java.util.Map;
import java.util.Set;

import lpg.runtime.ErrorToken;
import lpg.runtime.IToken;

import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EClass;

import org.eclipse.ocl.cst.PathNameCS;
import org.eclipse.ocl.cst.SimpleNameCS;
import org.eclipse.ocl.expressions.StringLiteralExp;
import org.eclipse.ocl.lpg.OCLParserStream;
import org.eclipse.qvt.declarative.ecore.utils.EcoreUtils;
import org.eclipse.qvt.declarative.ecore.utils.TracingOption;
import org.eclipse.qvt.declarative.editor.ui.QVTEditorPlugin;

	}
	
	protected IToken getToken() {
		OCLParserStream stream = parseResult.getParser().getIPrsStream();
		IToken errorToken = stream.getErrorTokenAtCharacter(offset);
		if (errorToken != null)
			return errorToken;

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonTokenColorer.java (-1 / +7 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IToken;
20		20
21	import org.eclipse.imp.parser.IParseController;	21	import org.eclipse.imp.parser.IParseController;
22	import org.eclipse.imp.services.ITokenColorer;	22	import org.eclipse.imp.services.ITokenColorer;
Lines 73-76 Link Here
73	return super.getColoring(controller, token);	73	return super.getColoring(controller, token);
74	}	74	}
75	}	75	}
		76
		77	public TextAttribute getInterColoring(IParseController controller,
		78	Object prevToken, Object nextToken) {
		79	// TODO Auto-generated method stub
		80	return null;
		81	}
76	}	82	}

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonSourcePositionLocator.java (-1 / +1 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IToken;
20		20
21	import org.eclipse.core.runtime.IPath;	21	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.Path;	22	import org.eclipse.core.runtime.Path;

Lines 33-39 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonParseController.java (-1 / +1 lines)
33	import java.util.Iterator;	33	import java.util.Iterator;
34	import java.util.List;	34	import java.util.List;
35		35
36	import lpg.lpgjavaruntime.IToken;	36	import lpg.runtime.IToken;
37		37
38	import org.eclipse.core.resources.IProject;	38	import org.eclipse.core.resources.IProject;
39	import org.eclipse.core.runtime.CoreException;	39	import org.eclipse.core.runtime.CoreException;




import java.util.HashMap;
import java.util.List;

import lpg.runtime.Adjunct;
import lpg.runtime.ILexStream;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.imp.services.base.FolderBase;
import org.eclipse.jface.text.Position;

		}
	};

	protected IPrsStream prsStream = null;

	protected abstract ICommonPlugin getPlugin();

	protected void makeAdjunctAnnotations(CSTNode theAST) {
		ILexStream lexStream = prsStream.getILexStream();
		if (lexStream == null)
			return;
		@SuppressWarnings("unchecked")

			IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];
			makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token
					.getLine() > last_token.getEndLine() ? prsStream
					.getILexStream().getLineOffset(gate_token.getLine() - 1)
					: last_token.getEndOffset());
		}
	}

		if (theCST != null) {
			IToken startToken = theCST.getStartToken();
			if (startToken != null) {
				prsStream = startToken.getIPrsStream();
				FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());
				visitor.enter(theCST);
				makeAdjunctAnnotations(theCST);

Lines 39-45 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonParseHelper.java (-1 / +1 lines)
39	keywords = new ArrayList<ICommonKeyword>();	39	keywords = new ArrayList<ICommonKeyword>();
40	int[] keywordKinds= parser.getLexer().getKeywordKinds();	40	int[] keywordKinds= parser.getLexer().getKeywordKinds();
41	for(int i= 1; i < keywordKinds.length; i++) {	41	for(int i= 1; i < keywordKinds.length; i++) {
42	int index= parser.mapKind(keywordKinds[i]);	42	int index= parser.getIPrsStream().mapKind(keywordKinds[i]);
43	fIsKeyword[index]= true;	43	fIsKeyword[index]= true;
44	keywords.add(createKeyword(tokenKindNames[index]));	44	keywords.add(createKeyword(tokenKindNames[index]));
45	}	45	}

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonProblemHandler.java (-2 / +3 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IPrsStream;
		20	import lpg.runtime.IToken;
20		21
21	import org.eclipse.core.resources.IMarker;	22	import org.eclipse.core.resources.IMarker;
22	import org.eclipse.imp.parser.IMessageHandler;	23	import org.eclipse.imp.parser.IMessageHandler;
Lines 42-48 Link Here
42	}	43	}
43		44
44	public IToken getNearestTokenAtCharacter(int offset) { // FIXME Move to AbstractParser	45	public IToken getNearestTokenAtCharacter(int offset) { // FIXME Move to AbstractParser
45	AbstractParser parser = getParser();	46	IPrsStream parser = getParser().getIPrsStream();
46	int maxIndex = parser.getSize();	47	int maxIndex = parser.getSize();
47	if (maxIndex <= 0)	48	if (maxIndex <= 0)
48	return null;	49	return null;




 */
package org.eclipse.qvt.declarative.editor.ui.utils;

import lpg.runtime.ILexStream;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.ocl.cst.CSTNode;


		IToken token = cstNode.getStartToken();
		if (token == null)
			return null;
		IPrsStream prsStream = token.getIPrsStream();
		if (prsStream == null)
			return null;
		ILexStream lexStream = prsStream.getILexStream();
		if (lexStream == null)
			return null;
		return lexStream.getFileName();

Lines 22-27 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/builder/MarkerProblemHandler.java (-2 / +5 lines)
22	import java.util.Map;	22	import java.util.Map;
23	import java.util.Set;	23	import java.util.Set;
24		24
		25	import lpg.runtime.IPrsStream;
		26
25	import org.eclipse.core.resources.IMarker;	27	import org.eclipse.core.resources.IMarker;
26	import org.eclipse.core.resources.IResource;	28	import org.eclipse.core.resources.IResource;
27	import org.eclipse.core.resources.IWorkspace;	29	import org.eclipse.core.resources.IWorkspace;
Lines 172-180 Link Here
172	String problemMessage, String processingContext, int startOffset, int endOffset) {	174	String problemMessage, String processingContext, int startOffset, int endOffset) {
173	int line = -1;	175	int line = -1;
174	if (startOffset >= 0) {	176	if (startOffset >= 0) {
175	int leftToken = Math.abs(getParser().getTokenIndexAtCharacter(startOffset)); // abs to move non-token to predecessor	177	IPrsStream stream = getParser().getIPrsStream();
		178	int leftToken = Math.abs(stream.getTokenIndexAtCharacter(startOffset)); // abs to move non-token to predecessor
176	if (leftToken >= 0)	179	if (leftToken >= 0)
177	line = getParser().getLine(leftToken);	180	line = stream.getLine(leftToken);
178	}	181	}
179	Integer severity = severityMap.get(problemSeverity);	182	Integer severity = severityMap.get(problemSeverity);
180	addMarker(severity != null ? severity.intValue() : IMarker.SEVERITY_ERROR,	183	addMarker(severity != null ? severity.intValue() : IMarker.SEVERITY_ERROR,

Return to bug 242153

Lines 20-29 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonFoldingUpdater.java (-8 / +8 lines)
20	import java.util.HashMap;	20	import java.util.HashMap;
21	import java.util.List;	21	import java.util.List;
22		22
23	import lpg.lpgjavaruntime.Adjunct;	23	import lpg.runtime.Adjunct;
24	import lpg.lpgjavaruntime.IToken;	24	import lpg.runtime.ILexStream;
25	import lpg.lpgjavaruntime.LexStream;	25	import lpg.runtime.IPrsStream;
26	import lpg.lpgjavaruntime.PrsStream;	26	import lpg.runtime.IToken;
27		27
28	import org.eclipse.imp.services.base.FolderBase;	28	import org.eclipse.imp.services.base.FolderBase;
29	import org.eclipse.jface.text.Position;	29	import org.eclipse.jface.text.Position;
Lines 62-73 Link Here
62	}	62	}
63	};	63	};
64		64
65	protected PrsStream prsStream = null;	65	protected IPrsStream prsStream = null;
66		66
67	protected abstract ICommonPlugin getPlugin();	67	protected abstract ICommonPlugin getPlugin();
68		68
69	protected void makeAdjunctAnnotations(CSTNode theAST) {	69	protected void makeAdjunctAnnotations(CSTNode theAST) {
70	LexStream lexStream = prsStream.getLexStream();	70	ILexStream lexStream = prsStream.getILexStream();
71	if (lexStream == null)	71	if (lexStream == null)
72	return;	72	return;
73	@SuppressWarnings("unchecked")	73	@SuppressWarnings("unchecked")
Lines 106-112 Link Here
106	IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];	106	IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];
107	makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token	107	makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token
108	.getLine() > last_token.getEndLine() ? prsStream	108	.getLine() > last_token.getEndLine() ? prsStream
109	.getLexStream().getLineOffset(gate_token.getLine() - 1)	109	.getILexStream().getLineOffset(gate_token.getLine() - 1)
110	: last_token.getEndOffset());	110	: last_token.getEndOffset());
111	}	111	}
112	}	112	}
Lines 127-133 Link Here
127	if (theCST != null) {	127	if (theCST != null) {
128	IToken startToken = theCST.getStartToken();	128	IToken startToken = theCST.getStartToken();
129	if (startToken != null) {	129	if (startToken != null) {
130	prsStream = startToken.getPrsStream();	130	prsStream = startToken.getIPrsStream();
131	FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());	131	FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());
132	visitor.enter(theCST);	132	visitor.enter(theCST);
133	makeAdjunctAnnotations(theCST);	133	makeAdjunctAnnotations(theCST);