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