KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > syntax > jedit > tokenmarker > ShellScriptTokenMarker


1 /*
2  * Copyright (C) 2005 - 2006 JasperSoft Corporation. All rights reserved.
3  * http://www.jaspersoft.com.
4  *
5  * Unless you have purchased a commercial license agreement from JasperSoft,
6  * the following license terms apply:
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as published by
10  * the Free Software Foundation.
11  *
12  * This program is distributed WITHOUT ANY WARRANTY; and without the
13  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14  * See the GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see http://www.gnu.org/licenses/gpl.txt
18  * or write to:
19  *
20  * Free Software Foundation, Inc.,
21  * 59 Temple Place - Suite 330,
22  * Boston, MA USA 02111-1307
23  *
24  *
25  *
26  *
27  * ShellScriptTokenMarker.java
28  *
29  */
30
31 package org.syntax.jedit.tokenmarker;
32
33 import org.syntax.jedit.*;
34 import javax.swing.text.Segment JavaDoc;
35
36 /**
37  * Shell script token marker.
38  *
39  * @author Slava Pestov
40  * @version $Id: ShellScriptTokenMarker.java 932 2006-10-20 09:32:45Z gtoffoli $
41  */
42 public class ShellScriptTokenMarker extends TokenMarker
43 {
44     // public members
45 public static final byte LVARIABLE = Token.INTERNAL_FIRST;
46
47     public byte markTokensImpl(byte token, Segment JavaDoc line, int lineIndex)
48     {
49         char[] array = line.array;
50         byte cmdState = 0; // 0 = space before command, 1 = inside
51 // command, 2 = after command
52 int offset = line.offset;
53         int lastOffset = offset;
54         int length = line.count + offset;
55
56         if(token == Token.LITERAL1 && lineIndex != 0
57             && lineInfo[lineIndex - 1].obj != null)
58         {
59             String JavaDoc str = (String JavaDoc)lineInfo[lineIndex - 1].obj;
60             if(str != null && str.length() == line.count
61                 && SyntaxUtilities.regionMatches(false,line,
62                 offset,str))
63             {
64                 addToken(line.count,Token.LITERAL1);
65                 return Token.NULL;
66             }
67             else
68             {
69                 addToken(line.count,Token.LITERAL1);
70                 lineInfo[lineIndex].obj = str;
71                 return Token.LITERAL1;
72             }
73         }
74
75         boolean backslash = false;
76 loop: for(int i = offset; i < length; i++)
77         {
78             int i1 = (i+1);
79
80             char c = array[i];
81
82             if(c == '\\')
83             {
84                 backslash = !backslash;
85                 continue;
86             }
87
88             switch(token)
89             {
90             case Token.NULL:
91                 switch(c)
92                 {
93                 case ' ': case '\t': case '(': case ')':
94                     backslash = false;
95                     if(cmdState == 1/*insideCmd*/)
96                     {
97                         addToken(i - lastOffset,Token.KEYWORD1);
98                         lastOffset = i;
99                         cmdState = 2; /*afterCmd*/
100                     }
101                     break;
102                 case '=':
103                     backslash = false;
104                     if(cmdState == 1/*insideCmd*/)
105                     {
106                         addToken(i - lastOffset,token);
107                         lastOffset = i;
108                         cmdState = 2; /*afterCmd*/
109                     }
110                     break;
111                 case '&': case '|': case ';':
112                     if(backslash)
113                         backslash = false;
114                     else
115                         cmdState = 0; /*beforeCmd*/
116                     break;
117                 case '#':
118                     if(backslash)
119                         backslash = false;
120                     else
121                     {
122                         addToken(i - lastOffset,token);
123                         addToken(length - i,Token.COMMENT1);
124                         lastOffset = length;
125                         break loop;
126                     }
127                     break;
128                 case '$':
129                     if(backslash)
130                         backslash = false;
131                     else
132                     {
133                         addToken(i - lastOffset,token);
134                         cmdState = 2; /*afterCmd*/
135                         lastOffset = i;
136                         if(length - i >= 2)
137                         {
138                             switch(array[i1])
139                             {
140                             case '(':
141                                 continue;
142                             case '{':
143                                 token = LVARIABLE;
144                                 break;
145                             default:
146                                 token = Token.KEYWORD2;
147                                 break;
148                             }
149                         }
150                         else
151                             token = Token.KEYWORD2;
152                     }
153                     break;
154                 case '"':
155                     if(backslash)
156                         backslash = false;
157                     else
158                     {
159                         addToken(i - lastOffset,token);
160                         token = Token.LITERAL1;
161                         lineInfo[lineIndex].obj = null;
162                         cmdState = 2; /*afterCmd*/
163                         lastOffset = i;
164                     }
165                     break;
166                 case '\'':
167                     if(backslash)
168                         backslash = false;
169                     else
170                     {
171                         addToken(i - lastOffset,token);
172                         token = Token.LITERAL2;
173                         cmdState = 2; /*afterCmd*/
174                         lastOffset = i;
175                     }
176                     break;
177                 case '<':
178                     if(backslash)
179                         backslash = false;
180                     else
181                     {
182                         if(length - i > 1 && array[i1] == '<')
183                         {
184                             addToken(i - lastOffset,
185                                 token);
186                             token = Token.LITERAL1;
187                             lastOffset = i;
188                             lineInfo[lineIndex].obj =
189                                 new String JavaDoc(array,i + 2,
190                                     length - (i+2));
191                         }
192                     }
193                     break;
194                 default:
195                     backslash = false;
196                     if(Character.isLetter(c))
197                     {
198                         if(cmdState == 0 /*beforeCmd*/)
199                         {
200                             addToken(i - lastOffset,token);
201                             lastOffset = i;
202                             cmdState++; /*insideCmd*/
203                         }
204                     }
205                     break;
206                 }
207                 break;
208             case Token.KEYWORD2:
209                 backslash = false;
210                 if(!Character.isLetterOrDigit(c) && c != '_')
211                 {
212                     if(i != offset && array[i-1] == '$')
213                     {
214                         addToken(i1 - lastOffset,token);
215                         lastOffset = i1;
216                         token = Token.NULL;
217                         continue;
218                     }
219                     else
220                     {
221                         addToken(i - lastOffset,token);
222                         lastOffset = i;
223                         token = Token.NULL;
224                     }
225                 }
226                 break;
227             case Token.LITERAL1:
228                 if(backslash)
229                     backslash = false;
230                 else if(c == '"')
231                 {
232                     addToken(i1 - lastOffset,token);
233                     cmdState = 2; /*afterCmd*/
234                     lastOffset = i1;
235                     token = Token.NULL;
236                 }
237                 else
238                     backslash = false;
239                 break;
240             case Token.LITERAL2:
241                 if(backslash)
242                     backslash = false;
243                 else if(c == '\'')
244                 {
245                     addToken(i1 - lastOffset,Token.LITERAL1);
246                     cmdState = 2; /*afterCmd*/
247                     lastOffset = i1;
248                     token = Token.NULL;
249                 }
250                 else
251                     backslash = false;
252                 break;
253             case LVARIABLE:
254                 backslash = false;
255                 if(c == '}')
256                 {
257                     addToken(i1 - lastOffset,Token.KEYWORD2);
258                     lastOffset = i1;
259                     token = Token.NULL;
260                 }
261                 break;
262             default:
263                 throw new InternalError JavaDoc("Invalid state: " + token);
264             }
265         }
266
267         switch(token)
268         {
269         case Token.NULL:
270             if(cmdState == 1)
271                 addToken(length - lastOffset,Token.KEYWORD1);
272             else
273                 addToken(length - lastOffset,token);
274             break;
275         case Token.LITERAL2:
276             addToken(length - lastOffset,Token.LITERAL1);
277             break;
278         case Token.KEYWORD2:
279             addToken(length - lastOffset,token);
280             token = Token.NULL;
281             break;
282         case LVARIABLE:
283             addToken(length - lastOffset,Token.INVALID);
284             token = Token.NULL;
285             break;
286         default:
287             addToken(length - lastOffset,token);
288             break;
289         }
290         return token;
291     }
292 }
293
Popular Tags