make compilable in 3.2
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / php / PHPCodeScanner.java
1 /**********************************************************************
2  Copyright (c) 2000, 2002 IBM Corp. and others.
3  All rights reserved. This program and the accompanying materials
4  are made available under the terms of the Common Public License v1.0
5  which accompanies this distribution, and is available at
6  http://www.eclipse.org/legal/cpl-v10.html
7
8  Contributors:
9  IBM Corporation - Initial implementation
10  www.phpeclipse.de
11  **********************************************************************/
12 package net.sourceforge.phpeclipse.phpeditor.php;
13
14 import java.util.ArrayList;
15 import java.util.HashMap;
16 import java.util.List;
17 import java.util.Map;
18
19 import net.sourceforge.phpdt.internal.ui.text.AbstractJavaScanner;
20 import net.sourceforge.phpdt.ui.text.IColorManager;
21 import net.sourceforge.phpeclipse.IPreferenceConstants;
22 import net.sourceforge.phpeclipse.phpeditor.PHPSyntaxRdr;
23 import net.sourceforge.phpeclipse.phpeditor.util.PHPWhitespaceDetector;
24 import net.sourceforge.phpeclipse.phpeditor.util.PHPWordDetector;
25
26 import org.eclipse.jface.preference.IPreferenceStore;
27 import org.eclipse.jface.text.Assert;
28 import org.eclipse.jface.text.rules.ICharacterScanner;
29 import org.eclipse.jface.text.rules.IRule;
30 import org.eclipse.jface.text.rules.IToken;
31 import org.eclipse.jface.text.rules.IWordDetector;
32 import org.eclipse.jface.text.rules.MultiLineRule;
33 import org.eclipse.jface.text.rules.Token;
34 import org.eclipse.jface.text.rules.WhitespaceRule;
35 import org.eclipse.jface.text.rules.WordRule;
36
37 /**
38  * PHP Code Scanner
39  */
40 public class PHPCodeScanner extends AbstractJavaScanner {
41
42         /**
43          * Rule to detect java operators.
44          *
45          * @since 3.0
46          */
47         protected class OperatorRule implements IRule {
48
49                 /** Java operators */
50                 private final char[] PHP_OPERATORS = { ';', '(', ')', '.', '=', '/', '\\', '+', '-', '*', '[', ']', '<', '>', ':', '?', '!',
51                                 ',', '|', '&', '^', '%', '~', '@' };
52
53                 /** Token to return for this rule */
54                 private final IToken fToken;
55
56                 /** Token to return for braces */
57                 private final IToken fTokenBraces;
58
59                 /** Token to return for heredocs */
60                 private final IToken fTokenHeredoc;
61
62                 /**
63                  * Creates a new operator rule.
64                  *
65                  * @param token
66                  *          Token to use for this rule
67                  * @param tokenHeredoc
68                  *          TODO
69                  */
70                 public OperatorRule(IToken token, IToken tokenBraces, IToken tokenHeredoc) {
71                         fToken = token;
72                         fTokenBraces = tokenBraces;
73                         fTokenHeredoc = tokenHeredoc;
74                 }
75
76                 /**
77                  * Is this character an operator character?
78                  *
79                  * @param character
80                  *          Character to determine whether it is an operator character
81                  * @return <code>true</code> iff the character is an operator,
82                  *         <code>false</code> otherwise.
83                  */
84                 public boolean isOperator(char character) {
85                         for (int index = 0; index < PHP_OPERATORS.length; index++) {
86                                 if (PHP_OPERATORS[index] == character)
87                                         return true;
88                         }
89                         return false;
90                 }
91
92                 /*
93                  * @see org.eclipse.jface.text.rules.IRule#evaluate(org.eclipse.jface.text.rules.ICharacterScanner)
94                  */
95                 public IToken evaluate(ICharacterScanner scanner) {
96
97                         int character = scanner.read();
98                         if (character == '{' || character == '}') {
99                                 return fTokenBraces;
100                         }
101                         if (isOperator((char) character)) {
102                                 int lastCharacter = character;
103                                 character = scanner.read();
104                                 // the readHEREDOC(scanner) call doesn't work, if we have our own partitions for single quoted
105                                 // or double quoted strings:
106                                 //
107                                 // if (lastCharacter == '<' && character == '<') {
108                                 // int heredocCharacter = scanner.read();
109                                 // if (heredocCharacter == '<') {
110                                 // // start of heredoc comment;
111                                 // if (readHEREDOC(scanner)) {
112                                 // return fTokenHeredoc;
113                                 // }
114                                 // } else {
115                                 // scanner.unread();
116                                 // }
117                                 // }
118                                 if (!isOperator((char) character)) {
119                                         scanner.unread();
120                                         return fToken;
121                                 }
122                                 if (checkPHPTag(scanner, lastCharacter, character)) {
123                                         return Token.UNDEFINED;
124                                 }
125                                 do {
126                                         lastCharacter = character;
127                                         character = scanner.read();
128                                         if (checkPHPTag(scanner, lastCharacter, character)) {
129                                                 return fToken;
130                                         }
131                                         if (character == ICharacterScanner.EOF) {
132                                                 return fToken;
133                                         }
134                                 } while (isOperator((char) character));
135                                 scanner.unread();
136                                 return fToken;
137                         } else {
138                                 scanner.unread();
139                                 return Token.UNDEFINED;
140                         }
141                 }
142
143                 // private boolean readHEREDOC(ICharacterScanner scanner) {
144                 // // search until heredoc ends
145                 // int ch;
146                 // StringBuffer buf = new StringBuffer();
147                 // char[] heredocIdent;
148                 //
149                 // ch = scanner.read();
150                 // if (!Scanner.isPHPIdentifierStart((char)ch)) {
151                 // scanner.unread();
152                 // scanner.unread();
153                 // return false;
154                 // }
155                 // while (Scanner.isPHPIdentifierPart((char)ch)) {
156                 // buf.append((char)ch);
157                 // ch = scanner.read();
158                 // }
159                 // if (ch==ICharacterScanner.EOF) {
160                 // return true;
161                 // }
162                 // heredocIdent = buf.toString().toCharArray();
163                 // while (true) {
164                 // ch = scanner.read();
165                 // if (ch==ICharacterScanner.EOF) {
166                 // return true;
167                 // }
168                 // if (ch == '\n') { // heredoc could end after a newline
169                 // int pos = 0;
170                 // while (true) {
171                 // if (pos == heredocIdent.length) {
172                 // return true;
173                 // }
174                 // ch = scanner.read(); // ignore escaped character
175                 // if (ch != heredocIdent[pos]) {
176                 // break;
177                 // }
178                 // if (ch==ICharacterScanner.EOF) {
179                 // return true;
180                 // }
181                 // pos++;
182                 // }
183                 // }
184                 // }
185                 // }
186
187                 /**
188                  * Check if lastCharacter/character are a PHP start or end token ( &lt;? ...
189                  * ?&gt; )
190                  *
191                  * @param scanner
192                  * @param lastCharacter
193                  * @param character
194                  * @return
195                  */
196                 private boolean checkPHPTag(ICharacterScanner scanner, int lastCharacter, int character) {
197                         if (lastCharacter == '<' && character == '?') {
198                                 scanner.unread();
199                                 scanner.unread();
200                                 return true;
201                         } else if (lastCharacter == '?' && character == '>') {
202                                 scanner.unread();
203                                 scanner.unread();
204                                 return true;
205                         }
206                         return false;
207                 }
208         }
209
210         protected class AccentStringRule implements IRule {
211
212                 /** Token to return for this rule */
213                 private final IToken fToken;
214
215                 public AccentStringRule(IToken token) {
216                         fToken = token;
217
218                 }
219
220                 /*
221                  * @see org.eclipse.jface.text.rules.IRule#evaluate(org.eclipse.jface.text.rules.ICharacterScanner)
222                  */
223                 public IToken evaluate(ICharacterScanner scanner) {
224
225                         int character = scanner.read();
226
227                         if (character == '`') {
228
229                                 while (character != ICharacterScanner.EOF) {
230                                         character = scanner.read();
231                                         if (character == '\\') {
232                                                 character = scanner.read();
233                                         } else if (character == '`') {
234                                                 return fToken;
235                                         }
236                                 }
237                                 scanner.unread();
238                                 return Token.UNDEFINED;
239                         } else {
240                                 scanner.unread();
241                                 return Token.UNDEFINED;
242                         }
243                 }
244
245         }
246
247         private class PHPWordRule extends WordRule {
248                 private StringBuffer fBuffer = new StringBuffer();
249
250                 protected Map fWordsIgnoreCase = new HashMap();
251
252                 public PHPWordRule(IWordDetector detector) {
253                         super(detector, Token.UNDEFINED);
254                 }
255
256                 public PHPWordRule(IWordDetector detector, IToken defaultToken) {
257                         super(detector, defaultToken);
258                 }
259
260                 /**
261                  * Adds a word and the token to be returned if it is detected.
262                  *
263                  * @param word
264                  *          the word this rule will search for, may not be <code>null</code>
265                  * @param token
266                  *          the token to be returned if the word has been found, may not be
267                  *          <code>null</code>
268                  */
269                 public void addWordIgnoreCase(String word, IToken token) {
270                         Assert.isNotNull(word);
271                         Assert.isNotNull(token);
272
273                         fWordsIgnoreCase.put(word, token);
274                 }
275
276                 public IToken evaluate(ICharacterScanner scanner) {
277                         int c = scanner.read();
278                         boolean isVariable = false;
279                         boolean isUnderscore = false;
280                         String word;
281                         if (c == '<') {
282                                 c = scanner.read();
283                                 if (c != '?') {
284                                         scanner.unread();
285                                         scanner.unread();
286                                         return Token.UNDEFINED;
287                                 } else {
288                                         c = scanner.read();
289                                         if (c == '=') { // <?=
290                                                 return getToken(IPreferenceConstants.PHP_TAG);
291                                         }
292                                         if (c != 'p' && c != 'P') {
293                                                 scanner.unread();
294                                                 return getToken(IPreferenceConstants.PHP_TAG);
295                                         } else {
296                                                 c = scanner.read();
297                                                 if (c != 'h' && c != 'H') {
298                                                         scanner.unread();
299                                                         scanner.unread();
300                                                         return getToken(IPreferenceConstants.PHP_TAG);
301                                                 } else {
302                                                         c = scanner.read();
303                                                         if (c != 'p' && c != 'P') {
304                                                                 scanner.unread();
305                                                                 scanner.unread();
306                                                                 scanner.unread();
307                                                                 return getToken(IPreferenceConstants.PHP_TAG);
308                                                         } else {
309                                                                 return getToken(IPreferenceConstants.PHP_TAG);
310                                                         }
311                                                 }
312                                         }
313                                 }
314                         }
315                         if (c == '?') {
316                                 c = scanner.read();
317                                 if (c == '>') {
318                                         return getToken(IPreferenceConstants.PHP_TAG);
319                                 }
320                                 scanner.unread();
321                                 scanner.unread();
322                                 return Token.UNDEFINED;
323                         }
324                         if (fDetector.isWordStart((char) c)) {
325                                 if (c == '$') {
326                                         isVariable = true;
327                                 }
328                                 if (fColumn == UNDEFINED || (fColumn == scanner.getColumn() - 1)) {
329
330                                         fBuffer.setLength(0);
331                                         fBuffer.append((char) c);
332                                         c = scanner.read();
333                                         if (c == '_') {
334                                                 isUnderscore = true;
335                                         }
336                                         while (c != ICharacterScanner.EOF && fDetector.isWordPart((char) c)) {
337                                                 fBuffer.append((char) c);
338                                                 c = scanner.read();
339                                         }
340                                         scanner.unread();
341
342                                         if (isVariable) {
343                                                 if (isUnderscore) {
344                                                         return getToken(IPreferenceConstants.PHP_VARIABLE_DOLLAR);
345                                                 }
346                                                 return getToken(IPreferenceConstants.PHP_VARIABLE);
347                                         }
348                                         word = fBuffer.toString();
349                                         IToken token = (IToken) fWords.get(word);
350                                         if (token != null)
351                                                 return token;
352
353                                         token = (IToken) fWordsIgnoreCase.get(word.toLowerCase());
354                                         if (token != null)
355                                                 return token;
356
357                                         if (fDefaultToken.isUndefined())
358                                                 unreadBuffer(scanner);
359
360                                         return fDefaultToken;
361                                 }
362                         }
363
364                         scanner.unread();
365                         return Token.UNDEFINED;
366                 }
367         }
368
369         // private PHPColorProvider fColorProvider;
370
371         private static String[] fgTokenProperties = { IPreferenceConstants.PHP_MULTILINE_COMMENT,
372                         IPreferenceConstants.PHP_SINGLELINE_COMMENT, IPreferenceConstants.PHP_TAG, IPreferenceConstants.PHP_KEYWORD,
373                         IPreferenceConstants.PHP_FUNCTIONNAME, IPreferenceConstants.PHP_VARIABLE, IPreferenceConstants.PHP_VARIABLE_DOLLAR,
374                         IPreferenceConstants.PHP_STRING_DQ, IPreferenceConstants.PHP_STRING_SQ, IPreferenceConstants.PHP_TYPE,
375                         IPreferenceConstants.PHP_CONSTANT, IPreferenceConstants.PHP_DEFAULT, IPreferenceConstants.PHP_OPERATOR,
376                         IPreferenceConstants.PHP_BRACE_OPERATOR, IPreferenceConstants.PHP_KEYWORD_RETURN };
377
378         /**
379          * Creates a PHP code scanner
380          */
381         // public PHPCodeScanner(JavaColorManager provider, IPreferenceStore store) {
382         public PHPCodeScanner(IColorManager manager, IPreferenceStore store) {
383                 super(manager, store);
384                 initialize();
385         }
386
387         /*
388          * @see AbstractJavaScanner#getTokenProperties()
389          */
390         protected String[] getTokenProperties() {
391                 return fgTokenProperties;
392         }
393
394         /*
395          * @see AbstractJavaScanner#createRules()
396          */
397         protected List createRules() {
398                 List rules = new ArrayList();
399                 Token token = getToken(IPreferenceConstants.PHP_SINGLELINE_COMMENT);
400                 // Add rule for single line comments.
401                 // rules.add(new EndOfLineRule("//", token)); //$NON-NLS-1$
402                 // rules.add(new EndOfLineRule("#", token)); //$NON-NLS-1$
403                 // Add rule for strings and character constants.
404                 // token = getToken(IPreferenceConstants.PHP_STRING_SQ);
405                 // rules.add(new SingleQuoteStringRule(token));
406                 // token = getToken(IPreferenceConstants.PHP_STRING_DQ);
407                 // rules.add(new DoubleQuoteStringRule(token));
408                 rules.add(new AccentStringRule(token));
409
410                 token = getToken(IPreferenceConstants.PHP_MULTILINE_COMMENT);
411                 rules.add(new MultiLineRule("/*", "*/", token)); //$NON-NLS-2$ //$NON-NLS-1$
412                 // Add generic whitespace rule.
413                 rules.add(new WhitespaceRule(new PHPWhitespaceDetector()));
414                 // Add word rule for keywords, types, and constants.
415                 token = getToken(IPreferenceConstants.PHP_DEFAULT);
416                 PHPWordRule wordRule = new PHPWordRule(new PHPWordDetector(), token);
417
418                 Token keyword = getToken(IPreferenceConstants.PHP_KEYWORD);
419                 Token functionName = getToken(IPreferenceConstants.PHP_FUNCTIONNAME);
420                 Token type = getToken(IPreferenceConstants.PHP_TYPE);
421                 Token constant = getToken(IPreferenceConstants.PHP_CONSTANT);
422
423                 ArrayList buffer = PHPSyntaxRdr.getSyntaxData();
424                 // String strbuffer = null; unused
425                 PHPElement elbuffer = null;
426                 String name;
427                 for (int i = 0; i < buffer.size(); i++) {
428                         // while ((buffer != null)
429                         // && (!buffer.isEmpty()
430                         // && ((elbuffer = (PHPElement) buffer.remove(0)) != null))) {
431                         elbuffer = (PHPElement) buffer.get(i);
432                         if (elbuffer instanceof PHPKeyword) {
433                                 name = ((PHPKeyword) elbuffer).getName();
434                                 if (!name.equals("return")) {
435                                         wordRule.addWord(name, keyword);
436                                 }
437                         } else if (elbuffer instanceof PHPFunction) {
438                                 wordRule.addWordIgnoreCase(((PHPFunction) elbuffer).getName(), functionName);
439                         } else if (elbuffer instanceof PHPType) {
440                                 wordRule.addWord(elbuffer.getName(), type);
441                         } else if (elbuffer instanceof PHPConstant) {
442                                 wordRule.addWord(elbuffer.getName(), constant);
443                         }
444                 }
445
446                 // Add word rule for keyword 'return'.
447                 token = getToken(IPreferenceConstants.PHP_KEYWORD_RETURN);
448                 wordRule.addWord("return", token);
449
450                 // Add rule for operators and brackets (at the end !)
451                 rules.add(new OperatorRule(getToken(IPreferenceConstants.PHP_OPERATOR), getToken(IPreferenceConstants.PHP_BRACE_OPERATOR),
452                                 getToken(IPreferenceConstants.PHP_STRING_DQ)));
453
454                 rules.add(wordRule);
455
456                 setDefaultReturnToken(getToken(IPreferenceConstants.PHP_DEFAULT));
457                 return rules;
458         }
459 }