misc parser changes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / php / Partition.java
1 /*
2  * Created on 28.04.2003
3  *
4  */
5 package net.sourceforge.phpeclipse.phpeditor.php;
6
7 import org.eclipse.jface.text.BadLocationException;
8 import org.eclipse.jface.text.IDocument;
9 import org.eclipse.jface.text.rules.ICharacterScanner;
10 import org.eclipse.jface.text.rules.IToken;
11 import org.eclipse.jface.text.rules.Token;
12
13
14 /**
15  * Defines a partition in a phpdocument. This class keeps tracks of
16  * partitions contained within other partitions.
17  * 
18  * @author Stefan Langer
19  * @version $Revision: 1.2 $
20  */
21 public abstract class Partition
22 {
23         private IDocument fDocument;
24         private IToken fContentToken;
25         private String fParentPartition;
26         private char[] fTextBuffer;
27         private int fOffset = 0;
28         private char entry;
29         private char exit;
30         private boolean inDoubleString = false;
31         private boolean inSingleString = false;
32         
33         public Partition(IDocument document, char[] delim, String contentType, String parentPartition)
34         {
35                 fDocument = document;
36                 fContentToken = new Token(contentType);
37                 fParentPartition = parentPartition;
38                 entry = delim[0];
39                 exit = delim[1];
40         }
41         
42         public Partition(IDocument document, char[] delim, String contentType)
43         {
44                 this(document, delim, contentType, IPHPPartitionScannerConstants.HTML);
45         }
46         
47         /**
48          * Checks wether the specified type is allowed within this 
49          * partition type.
50          * 
51      * @param type The type of the partition to check.
52      * 
53      * @return <code>true</code> if the partition is allowed within this
54      *                  partition otherwise <code>false</code>.
55      */
56     abstract protected boolean allowedPartition(String type);
57     
58     abstract protected boolean scan();
59     
60     protected boolean isEnd()
61     {
62         return fOffset >= fTextBuffer.length;           
63     }
64     
65     protected int read()
66     {
67         if(fOffset > fTextBuffer.length)
68                 return ICharacterScanner.EOF;
69         
70         char ret = fTextBuffer[fOffset++];
71         switch(ret)
72         {
73                 case '\'':
74                         if(!inDoubleString)
75                                 inSingleString = !inSingleString;
76                         break;
77                 case '"':
78                         if(!inSingleString)
79                                 inDoubleString = !inDoubleString;
80                         break;
81         }
82         return ret;
83     }
84     
85     protected void unread(int i)
86     {
87         for (int j = 0; j < i && fOffset > 0; j++)
88         {
89             char read = fTextBuffer[--fOffset];
90
91             switch (read)
92             {
93                 case '\'' :
94                     if (!inDoubleString)
95                         inSingleString = !inSingleString;
96                     break;
97                 case '"' :
98                     if (!inSingleString)
99                         inDoubleString = !inDoubleString;
100                     break;
101             }
102         } // END FOR
103     }
104     
105     public boolean scanRange(int offset, int length)
106         throws BadLocationException
107     {   // short circuit scanning if entry is not correct
108         if (fDocument.getChar(offset) != entry)
109             return false;
110                 // read the full range into the internal buffer
111                 fOffset = 0;
112                 inSingleString = false;
113                 inDoubleString = false;
114         fTextBuffer = fDocument.get(offset, length).toCharArray();
115         return scan();
116     }
117     
118     protected boolean checkPattern(String pattern, boolean ignoreCase)
119     {
120         char[] checkPattern = pattern.toCharArray();
121         int offset = fOffset;
122         for(int i=0; i<checkPattern.length; i++)
123         {
124                 if(isEnd() || !letterEquals(read(), checkPattern[i], ignoreCase))
125                 {
126                         fOffset = offset;
127                         return false;
128                 }
129         }
130         return true;
131     }
132         
133         private boolean letterEquals(int test, char letter, boolean ignoreCase)
134         {
135                 if (test == letter)
136                         return true;
137                 else if (
138                         ignoreCase
139                                 && Character.isLowerCase(letter)
140                                 && test == Character.toUpperCase(letter))
141                         return true;
142                 else if (
143                         ignoreCase
144                                 && Character.isUpperCase(letter)
145                                 && test == Character.toLowerCase(letter))
146                         return true;
147
148                 return false;
149         }
150     
151
152     
153     protected boolean inString()
154     {
155         return inDoubleString || inSingleString;
156     }
157     
158     
159     
160     
161     public IToken getToken()
162     {
163                 return fContentToken;
164     }
165     
166     public int getLength()
167     {
168         return fOffset;
169     }
170     
171     /**
172      * @return
173      */
174     public IDocument getDocument()
175     {
176         return fDocument;
177     }
178
179     /**
180      * @return
181      */
182     public String getParentPartition()
183     {
184         return fParentPartition;
185     }
186
187     /**
188      * @param document
189      */
190     public void setDocument(IDocument document)
191     {
192         fDocument = document;
193     }
194
195     /**
196      * @param string
197      */
198     public void setParentPartition(String string)
199     {
200         fParentPartition = string;
201     }
202     
203     
204     /**
205      * @return
206      */
207     public char getEntry()
208     {
209         return entry;
210     }
211
212     /**
213      * @return
214      */
215     public char getExit()
216     {
217         return exit;
218     }
219
220     /**
221      * @return
222      */
223     protected int getOffset()
224     {
225         return fOffset;
226     }
227
228     /**
229      * @param i
230      */
231     protected void setOffset(int i)
232     {
233         fOffset = i;
234     }
235
236 }