Acceso a clase
[PL2.git] / Conflex.java
1 // $ANTLR : "Conflex.g" -> "Conflex.java"$
2
3 import java.io.InputStream;
4 import antlr.TokenStreamException;
5 import antlr.TokenStreamIOException;
6 import antlr.TokenStreamRecognitionException;
7 import antlr.CharStreamException;
8 import antlr.CharStreamIOException;
9 import antlr.ANTLRException;
10 import java.io.Reader;
11 import java.util.Hashtable;
12 import antlr.CharScanner;
13 import antlr.InputBuffer;
14 import antlr.ByteBuffer;
15 import antlr.CharBuffer;
16 import antlr.Token;
17 import antlr.CommonToken;
18 import antlr.RecognitionException;
19 import antlr.NoViableAltForCharException;
20 import antlr.MismatchedCharException;
21 import antlr.TokenStream;
22 import antlr.ANTLRHashString;
23 import antlr.LexerSharedInputState;
24 import antlr.collections.impl.BitSet;
25 import antlr.SemanticException;
26
27 public class Conflex extends antlr.CharScanner implements ConflexTokenTypes, TokenStream
28  {
29 public Conflex(InputStream in) {
30         this(new ByteBuffer(in));
31 }
32 public Conflex(Reader in) {
33         this(new CharBuffer(in));
34 }
35 public Conflex(InputBuffer ib) {
36         this(new LexerSharedInputState(ib));
37 }
38 public Conflex(LexerSharedInputState state) {
39         super(state);
40         caseSensitiveLiterals = true;
41         setCaseSensitive(true);
42         literals = new Hashtable();
43 }
44
45 public Token nextToken() throws TokenStreamException {
46         Token theRetToken=null;
47 tryAgain:
48         for (;;) {
49                 Token _token = null;
50                 int _ttype = Token.INVALID_TYPE;
51                 resetText();
52                 try {   // for char stream error handling
53                         try {   // for lexical error handling
54                                 switch ( LA(1)) {
55                                 case '\t':  case '\r':  case ';':
56                                 {
57                                         mBT(true);
58                                         theRetToken=_returnToken;
59                                         break;
60                                 }
61                                 case 'A':  case 'B':  case 'C':  case 'D':
62                                 case 'E':  case 'F':  case 'G':  case 'H':
63                                 case 'I':  case 'J':  case 'K':  case 'L':
64                                 case 'M':  case 'N':  case 'O':  case 'P':
65                                 case 'Q':  case 'R':  case 'S':  case 'T':
66                                 case 'U':  case 'V':  case 'W':  case 'X':
67                                 case 'Y':  case 'Z':  case 'a':  case 'b':
68                                 case 'c':  case 'd':  case 'e':  case 'f':
69                                 case 'g':  case 'h':  case 'i':  case 'j':
70                                 case 'k':  case 'l':  case 'm':  case 'n':
71                                 case 'o':  case 'p':  case 'q':  case 'r':
72                                 case 's':  case 't':  case 'u':  case 'v':
73                                 case 'w':  case 'x':  case 'y':  case 'z':
74                                 {
75                                         mMODULO(true);
76                                         theRetToken=_returnToken;
77                                         break;
78                                 }
79                                 default:
80                                 {
81                                         if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
82                                 else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
83                                 }
84                                 }
85                                 if ( _returnToken==null ) continue tryAgain; // found SKIP token
86                                 _ttype = _returnToken.getType();
87                                 _ttype = testLiteralsTable(_ttype);
88                                 _returnToken.setType(_ttype);
89                                 return _returnToken;
90                         }
91                         catch (RecognitionException e) {
92                                 throw new TokenStreamRecognitionException(e);
93                         }
94                 }
95                 catch (CharStreamException cse) {
96                         if ( cse instanceof CharStreamIOException ) {
97                                 throw new TokenStreamIOException(((CharStreamIOException)cse).io);
98                         }
99                         else {
100                                 throw new TokenStreamException(cse.getMessage());
101                         }
102                 }
103         }
104 }
105
106         public final void mBT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
107                 int _ttype; Token _token=null; int _begin=text.length();
108                 _ttype = BT;
109                 int _saveIndex;
110                 
111                 {
112                 switch ( LA(1)) {
113                 case '\t':
114                 {
115                         match('\t');
116                         break;
117                 }
118                 case ';':
119                 {
120                         match(';');
121                         break;
122                 }
123                 case '\r':
124                 {
125                         match("\r\n");
126                         break;
127                 }
128                 default:
129                 {
130                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
131                 }
132                 }
133                 }
134                 _ttype = Token.SKIP;
135                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
136                         _token = makeToken(_ttype);
137                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
138                 }
139                 _returnToken = _token;
140         }
141         
142         protected final void mLETRA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
143                 int _ttype; Token _token=null; int _begin=text.length();
144                 _ttype = LETRA;
145                 int _saveIndex;
146                 
147                 {
148                 switch ( LA(1)) {
149                 case 'a':  case 'b':  case 'c':  case 'd':
150                 case 'e':  case 'f':  case 'g':  case 'h':
151                 case 'i':  case 'j':  case 'k':  case 'l':
152                 case 'm':  case 'n':  case 'o':  case 'p':
153                 case 'q':  case 'r':  case 's':  case 't':
154                 case 'u':  case 'v':  case 'w':  case 'x':
155                 case 'y':  case 'z':
156                 {
157                         matchRange('a','z');
158                         break;
159                 }
160                 case 'A':  case 'B':  case 'C':  case 'D':
161                 case 'E':  case 'F':  case 'G':  case 'H':
162                 case 'I':  case 'J':  case 'K':  case 'L':
163                 case 'M':  case 'N':  case 'O':  case 'P':
164                 case 'Q':  case 'R':  case 'S':  case 'T':
165                 case 'U':  case 'V':  case 'W':  case 'X':
166                 case 'Y':  case 'Z':
167                 {
168                         matchRange('A','Z');
169                         break;
170                 }
171                 default:
172                 {
173                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
174                 }
175                 }
176                 }
177                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
178                         _token = makeToken(_ttype);
179                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
180                 }
181                 _returnToken = _token;
182         }
183         
184         protected final void mDIGITO(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
185                 int _ttype; Token _token=null; int _begin=text.length();
186                 _ttype = DIGITO;
187                 int _saveIndex;
188                 
189                 {
190                 matchRange('0','9');
191                 }
192                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
193                         _token = makeToken(_ttype);
194                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
195                 }
196                 _returnToken = _token;
197         }
198         
199         protected final void mPUNTUACION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
200                 int _ttype; Token _token=null; int _begin=text.length();
201                 _ttype = PUNTUACION;
202                 int _saveIndex;
203                 
204                 {
205                 switch ( LA(1)) {
206                 case '\\':
207                 {
208                         match('\\');
209                         break;
210                 }
211                 case ':':
212                 {
213                         match(':');
214                         break;
215                 }
216                 case ' ':
217                 {
218                         match(' ');
219                         break;
220                 }
221                 case '(':
222                 {
223                         match('(');
224                         break;
225                 }
226                 case ')':
227                 {
228                         match(')');
229                         break;
230                 }
231                 default:
232                 {
233                         throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
234                 }
235                 }
236                 }
237                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
238                         _token = makeToken(_ttype);
239                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
240                 }
241                 _returnToken = _token;
242         }
243         
244         protected final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
245                 int _ttype; Token _token=null; int _begin=text.length();
246                 _ttype = IDENT;
247                 int _saveIndex;
248                 
249                 mLETRA(false);
250                 {
251                 _loop14821:
252                 do {
253                         switch ( LA(1)) {
254                         case 'A':  case 'B':  case 'C':  case 'D':
255                         case 'E':  case 'F':  case 'G':  case 'H':
256                         case 'I':  case 'J':  case 'K':  case 'L':
257                         case 'M':  case 'N':  case 'O':  case 'P':
258                         case 'Q':  case 'R':  case 'S':  case 'T':
259                         case 'U':  case 'V':  case 'W':  case 'X':
260                         case 'Y':  case 'Z':  case 'a':  case 'b':
261                         case 'c':  case 'd':  case 'e':  case 'f':
262                         case 'g':  case 'h':  case 'i':  case 'j':
263                         case 'k':  case 'l':  case 'm':  case 'n':
264                         case 'o':  case 'p':  case 'q':  case 'r':
265                         case 's':  case 't':  case 'u':  case 'v':
266                         case 'w':  case 'x':  case 'y':  case 'z':
267                         {
268                                 mLETRA(false);
269                                 break;
270                         }
271                         case '0':  case '1':  case '2':  case '3':
272                         case '4':  case '5':  case '6':  case '7':
273                         case '8':  case '9':
274                         {
275                                 mDIGITO(false);
276                                 break;
277                         }
278                         case ' ':  case '(':  case ')':  case ':':
279                         case '\\':
280                         {
281                                 mPUNTUACION(false);
282                                 break;
283                         }
284                         default:
285                         {
286                                 break _loop14821;
287                         }
288                         }
289                 } while (true);
290                 }
291                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
292                         _token = makeToken(_ttype);
293                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
294                 }
295                 _returnToken = _token;
296         }
297         
298         public final void mMODULO(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
299                 int _ttype; Token _token=null; int _begin=text.length();
300                 _ttype = MODULO;
301                 int _saveIndex;
302                 
303                 mIDENT(false);
304                 match(".mod");
305                 if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
306                         _token = makeToken(_ttype);
307                         _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
308                 }
309                 _returnToken = _token;
310         }
311         
312         
313         
314         }