1) Reintroduced some out commented methods. (Did break some preference settings)
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpdt / internal / ui / text / PHPCodeReader.java
1 package net.sourceforge.phpdt.internal.ui.text;
2
3 /*
4  * (c) Copyright IBM Corp. 2000, 2001.
5  * All Rights Reserved.
6  */
7
8 import java.io.IOException;
9
10 import net.sourceforge.phpdt.internal.corext.phpdoc.SingleCharReader;
11
12 import org.eclipse.jface.text.BadLocationException;
13 import org.eclipse.jface.text.IDocument;
14
15 /**
16  * Reads from a document either forwards or backwards. May be configured to skip
17  * comments and strings.
18  */
19 public class PHPCodeReader extends SingleCharReader {
20
21         /** The EOF character */
22         public static final int EOF = -1;
23         private boolean fSkipComments = false;
24         private boolean fSkipStrings  = false;
25         private boolean fForward      = false;
26         
27         private IDocument fDocument;
28         
29         private int fOffset;                           // The current text position within the editor's text
30         private int fEnd              = -1;
31         private int fCachedLineNumber = -1;            // Holds the last line we checked for single line comments
32
33         public PHPCodeReader() {
34         }
35
36         /**
37          * Returns the offset of the last read character. Should only be called
38          * after read has been called.
39          */
40         public int getOffset() {
41                 return fForward ? fOffset - 1 : fOffset;
42         }
43
44         public void configureForwardReader(IDocument document, int offset,
45                         int length, boolean skipComments, boolean skipStrings)
46                         throws IOException {
47                 fDocument = document;
48                 fOffset = offset;
49                 fSkipComments = skipComments;
50                 fSkipStrings = skipStrings;
51
52                 fForward = true;
53                 fEnd = Math.min(fDocument.getLength(), fOffset + length);
54         }
55
56         public void configureBackwardReader(IDocument document, int offset,
57                         boolean skipComments, boolean skipStrings) throws IOException {
58                 fDocument = document;
59                 fOffset = offset;
60                 fSkipComments = skipComments;
61                 fSkipStrings = skipStrings;
62
63                 fForward = false;
64                 try {
65                         fCachedLineNumber = fDocument.getLineOfOffset(fOffset);
66                 } catch (BadLocationException x) {
67                         throw new IOException(x.getMessage());
68                 }
69         }
70
71         /*
72          * @see Reader#close()
73          */
74         public void close() throws IOException {
75                 fDocument = null;
76         }
77
78         /*
79          * @see SingleCharReader#read()
80          */
81         public int read() throws IOException {
82                 try {
83                         return fForward ? readForwards() : readBackwards();
84                 } catch (BadLocationException x) {
85                         throw new IOException(x.getMessage());
86                 }
87         }
88
89         private int gotoCommentEnd (int nTextPos) throws BadLocationException {
90                 while (nTextPos < fEnd) {
91                         char current = fDocument.getChar (nTextPos++);
92                         
93                         if (current == '*') {
94                                 if ((nTextPos < fEnd) && 
95                                     (fDocument.getChar (nTextPos) == '/')) {
96                                         ++nTextPos;
97                                         
98                                         return nTextPos;
99                                 }
100                         }
101                 }
102                 
103                 return nTextPos;
104         }
105
106         /**
107          * 
108          * @param delimiter
109          * @throws BadLocationException
110          */
111         private int gotoStringEnd (int nTextPos, char delimiter) throws BadLocationException {
112                 while (nTextPos < fEnd) {               // If long as we are not at the end of text
113                         char current = fDocument.getChar (nTextPos++);
114                         
115                         if (current == '\\') {                          // ignore escaped characters
116                                 ++nTextPos;
117                         } 
118                         else if (current == delimiter) {
119                                 return nTextPos;
120                         }
121                 }
122                 
123                 return nTextPos;                        // End position
124         }
125
126         /**
127          * 
128          * @param nTextPos               The current text position
129          * 
130          * @return                       The position of the start of next line
131          * 
132          * @throws BadLocationException
133          */
134         private int gotoLineEnd (int nTextPos) throws BadLocationException {
135                 int line = fDocument.getLineOfOffset (nTextPos); // Get the line number of the current text position
136                 
137                 return fDocument.getLineOffset (line + 1);
138         }
139
140         private int readForwards () throws BadLocationException {
141                 while (fOffset < fEnd) {
142                         char current = fDocument.getChar(fOffset++);
143
144                         switch (current) {
145                             case '"':
146                             case '\'':
147                                 if (fSkipStrings) {
148                                     fOffset = gotoStringEnd (fOffset, current);
149                                     continue;
150                                 }
151                                 return current;
152                                 
153                             case '#':
154                                 if (fSkipComments && fOffset < fEnd) {
155                                     fOffset = gotoLineEnd (fOffset);
156                                     continue;
157                                 }
158                                 return current;
159
160                             case '/':
161                                 if (fSkipComments && fOffset < fEnd) {
162                                     char next = fDocument.getChar(fOffset);
163                                     
164                                     if (next == '*') {                                  // A comment starts, advance to the comment end
165                                         ++fOffset;
166                                         fOffset = gotoCommentEnd (fOffset);
167                                         continue;
168                                     } else if (next == '/') {                   // '//'-comment starts, advance to the line end
169                                         fOffset = gotoLineEnd (fOffset);
170                                         continue;
171                                     }
172                                 }    
173                                 return current;
174                         }
175
176                         return current;
177                 }
178
179                 return EOF;
180         }
181
182         /**
183          * Check whether the current line contains a single line comment.
184          * If it contains a single line comment (// or #), than set fOffset (the global character index)
185          * to the character just before the single line comment.
186          * 
187          * @throws BadLocationException
188          */
189         
190         private void handleSingleLineComment () throws BadLocationException {
191             char current;
192                 int  line = fDocument.getLineOfOffset (fOffset);         // Get the line number which belongs to the current text position fOffset
193                 
194                 if (line < fCachedLineNumber) {                          // If we didn't parse this line already
195                         fCachedLineNumber = line;                            // Remember this line for the next time (so we don't search again!)   
196                         int nOffset       = fDocument.getLineOffset (line);  // Get the start position of current line      
197                         
198                         while (nOffset < fOffset) {                          // As long as the text position is within the current line 
199                                 current = fDocument.getChar (nOffset);           // Get the character from the current text position
200
201                                 switch (current) {
202                                     case '/':
203                                         if (fDocument.getChar (nOffset + 1) == '/') { // If the following character is '/'
204                                             fOffset = nOffset - 1;
205                                             
206                                             return;
207                                         }
208                                         break;    
209                                     
210                                     case '#':
211                         fOffset = nOffset - 1;
212                         return;
213                                     
214                                     case '"':                                           // It's a string start quote
215                                     case '\'':
216                                         nOffset++;                                      // Set to next character
217                                         
218                                         while (nOffset < fOffset) {                     // As long as we are within the same line
219                                             char cChar = fDocument.getChar (nOffset++);
220                                             
221                                             if (cChar == '\\') {                        // Ignore escaped characters
222                                                 ++nOffset;
223                                             } 
224                                             else if (cChar == current) {                // If end of string found 
225                                                 break;
226                                             }
227                                         }
228                                         break;
229                                 }
230                                 
231                                 nOffset++;                                              // Go for the next character
232                         }
233                 }
234         }
235
236         /**
237          * We search the for the block comment start sequence "/*"
238          * 
239          * The returned value points to the '/'
240          * 
241          * @throws BadLocationException
242          * 
243          * @return The new text position
244          */
245         
246         private int gotoCommentStart (int nTextPos) throws BadLocationException {
247                 while (0 < nTextPos) {                                // As long as we are not at the start of the editor text
248                     char current = fDocument.getChar (nTextPos--);    // Get the character from the current text position        
249                         
250                         if ((current == '*') &&                           // If current character is a '*' 
251                             (0 <= nTextPos) &&                            // and if we are not yet at the start of the editor text 
252                             (fDocument.getChar (nTextPos) == '/')) {      // and the previous character is a '/', 
253                                 return nTextPos;                              // We found the block comment start "/*"
254                         }
255                 }
256                 
257                 return nTextPos;
258         }
259
260         /**
261          * The string closing quote has been found, when reading the editor text backwards.
262          * So we have to search for the start of the string
263          * 
264          * The returned value points to '"' or '''
265          * 
266          * @param delimiter The string double quote '"' or single ''' quote we search for
267          * 
268          * @throws BadLocationException
269          */
270         private int gotoStringStart (int nTextPos, char delimiter) throws BadLocationException {
271                 while (0 < nTextPos) {                              // As long as we are not at the start of the editor text
272                         char current = fDocument.getChar (nTextPos);    // Get the character from the current text position 
273                                                                         
274                         if (current == delimiter) {                     // If we found the same character ('"' or ''') again, we have found the string start
275                                 if (!(0 <= nTextPos &&                        
276                                       fDocument.getChar (nTextPos - 1) == '\\')) // If the character before the string quote is not an '/' 
277                                 return nTextPos;                                 // we found the string start
278                         }
279                                                                             
280                         --nTextPos;                                          // Go one character back
281                 }
282                 
283                 return nTextPos;
284         }
285
286         /**
287          * Read the editor text backwards
288          * 
289          */
290         
291         private int readBackwards() throws BadLocationException {
292             char current;                                                // The character on position fOffset
293             
294                 while (0 < fOffset) {                                        // As long as we are not at the beginning of the editor text
295                         --fOffset;                                               // Step back one character
296
297                         handleSingleLineComment ();                              // Search for a single line comment within the current line
298                                                                                  // If there is a single line comment, fOffset is set to position just before the single line comment
299
300                         current = fDocument.getChar (fOffset);                   // Read the current character
301                         switch (current) {                                       // Process the current character
302                             case '/':                                            // Is it a single line comment? 
303                                 if (fSkipComments &&                             // When comments should be skipped when parsing
304                                     fOffset > 1) {                               // and if there is indeed an additional character before that '/'
305                                     char prev = fDocument.getChar (fOffset - 1); // Look at the character in front of the '/'
306                                     
307                                     if (prev == '*') {                           // If '*' than a block comment ends here, advance to the comment start
308                                         fOffset -= 2;                            // Set character pointer to character before "*/"
309                                         fOffset  = gotoCommentStart (fOffset);   // and search for the starting "/*" of the block comment
310                                         continue;
311                                     }
312                                 }
313                                 return current;                                  // No block comment end, so return the current character
314                                 
315                             case '"':                                            // Is it a string double quote closing '"'?                                                
316                             case '\'':                                           // or a string single quote closing '''?
317                                 if (fSkipStrings) {                              // If we should skip strings when parsing
318                                     --fOffset;                                   // Set pointer one before the string closing quote 
319                                     fOffset = gotoStringStart (fOffset, current);// and search the start of string ('"' or ''')
320                                     continue;
321                                 }
322                                 return current;                                  // No string skip, so return the current character
323                         }
324
325                         return current;                                          // No string and no comment
326                 }
327
328                 return EOF;                                                  // When the start of the text has been found
329         }
330 }