Coverage Report

Coverage Report - org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers.BooleanFunctionLexer

Classes in this File

Line Coverage

Branch Coverage

Complexity

BooleanFunctionLexer

62%

95/153

14%

25/167

8.714

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 
 // $ANTLR 3.1.1 BooleanFunction.g 2009-06-03 01:05:39
  package org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers;
 
 import org.antlr.runtime.CharStream;
 import org.antlr.runtime.EarlyExitException;
 import org.antlr.runtime.Lexer;
 import org.antlr.runtime.MismatchedSetException;
 import org.antlr.runtime.NoViableAltException;
 import org.antlr.runtime.RecognitionException;
 import org.antlr.runtime.RecognizerSharedState;
 
 public class BooleanFunctionLexer extends Lexer {
     public static final int UPPERCASE=9;
     public static final int LOWERCASE=12;
     public static final int RP=7;
     public static final int OR=4;
     public static final int LP=6;
     public static final int NUMBER=10;
     public static final int WHITESPACE=11;
     public static final int AND=5;
     public static final int EOF=-1;
     public static final int ALPHA=8;
 
     // delegates
     // delegators
 
     public BooleanFunctionLexer() {;}
     public BooleanFunctionLexer(CharStream input) {
         this(input, new RecognizerSharedState());
     }
     public BooleanFunctionLexer(CharStream input, RecognizerSharedState state) {
         super(input,state);
 
     }
     public String getGrammarFileName() { return "BooleanFunction.g"; }
 
     // $ANTLR start "OR"
     public final void mOR() throws RecognitionException {
         try {
             int _type = OR;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:5:4: ( '+' )
             // BooleanFunction.g:5:6: '+'
             {
             match('+');
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "OR"
 
     // $ANTLR start "AND"
     public final void mAND() throws RecognitionException {
         try {
             int _type = AND;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:6:5: ( '*' )
             // BooleanFunction.g:6:7: '*'
             {
             match('*');
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "AND"
 
     // $ANTLR start "LP"
     public final void mLP() throws RecognitionException {
         try {
             int _type = LP;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:7:4: ( '(' )
             // BooleanFunction.g:7:6: '('
             {
             match('(');
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "LP"
 
     // $ANTLR start "RP"
     public final void mRP() throws RecognitionException {
         try {
             int _type = RP;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:8:4: ( ')' )
             // BooleanFunction.g:8:6: ')'
             {
             match(')');
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "RP"
 
     // $ANTLR start "ALPHA"
     public final void mALPHA() throws RecognitionException {
         try {
             int _type = ALPHA;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:69:9: ( UPPERCASE | ( UPPERCASE NUMBER ) )
             int alt1=2;
             int LA1_0 = input.LA(1);
 
             if ( ((LA1_0>='A' && LA1_0<='Z')) ) {
                 int LA1_1 = input.LA(2);
 
                 if ( ((LA1_1>='0' && LA1_1<='9')) ) {
                     alt1=2;
                 }
                 else {
                     alt1=1;}
             }
             else {
                 NoViableAltException nvae =
                     new NoViableAltException("", 1, 0, input);
 
                 throw nvae;
             }
             switch (alt1) {
                 case 1 :
                     // BooleanFunction.g:69:11: UPPERCASE
                     {
                     mUPPERCASE();
 
                     }
                     break;
                 case 2 :
                     // BooleanFunction.g:69:23: ( UPPERCASE NUMBER )
                     {
                     // BooleanFunction.g:69:23: ( UPPERCASE NUMBER )
                     // BooleanFunction.g:69:24: UPPERCASE NUMBER
                     {
                     mUPPERCASE();
                     mNUMBER();
 
                     }
 
 
                     }
                     break;
 
             }
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "ALPHA"
 
     // $ANTLR start "NUMBER"
     public final void mNUMBER() throws RecognitionException {
         try {
             int _type = NUMBER;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:71:9: ( ( '0' .. '9' )+ )
             // BooleanFunction.g:71:11: ( '0' .. '9' )+
             {
             // BooleanFunction.g:71:11: ( '0' .. '9' )+
             int cnt2=0;
             loop2:
             do {
                 int alt2=2;
                 int LA2_0 = input.LA(1);
 
                 if ( ((LA2_0>='0' && LA2_0<='9')) ) {
                     alt2=1;
                 }
 
 
                 switch (alt2) {
                     case 1 :
                         // BooleanFunction.g:71:12: '0' .. '9'
                         {
                         matchRange('0','9');
 
                         }
                         break;
 
                     default :
                         if ( cnt2 >= 1 ) break loop2;
                         EarlyExitException eee =
                             new EarlyExitException(2, input);
                         throw eee;
                 }
                 cnt2++;
             } while (true);
 
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "NUMBER"
 
     // $ANTLR start "WHITESPACE"
     public final void mWHITESPACE() throws RecognitionException {
         try {
             int _type = WHITESPACE;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:73:12: ( ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )+ )
             // BooleanFunction.g:73:14: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )+
             {
             // BooleanFunction.g:73:14: ( '\\t' | ' ' | '\\r' | '\\n' | '\\u000C' )+
             int cnt3=0;
             loop3:
             do {
                 int alt3=2;
                 int LA3_0 = input.LA(1);
 
                 if ( ((LA3_0>='\t' && LA3_0<='\n')||(LA3_0>='\f' && LA3_0<='\r')||LA3_0==' ') ) {
                     alt3=1;
                 }
 
 
                 switch (alt3) {
                     case 1 :
                         // BooleanFunction.g:
                         {
                         if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ' ) {
                             input.consume();
 
                         }
                         else {
                             MismatchedSetException mse = new MismatchedSetException(null,input);
                             recover(mse);
                             throw mse;}
 
 
                         }
                         break;
 
                     default :
                         if ( cnt3 >= 1 ) break loop3;
                         EarlyExitException eee =
                             new EarlyExitException(3, input);
                         throw eee;
                 }
                 cnt3++;
             } while (true);
 
              _channel = HIDDEN;
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "WHITESPACE"
 
     // $ANTLR start "LOWERCASE"
     public final void mLOWERCASE() throws RecognitionException {
         try {
             int _type = LOWERCASE;
             int _channel = DEFAULT_TOKEN_CHANNEL;
             // BooleanFunction.g:75:11: ( 'a' .. 'z' )
             // BooleanFunction.g:75:13: 'a' .. 'z'
             {
             matchRange('a','z');
 
             }
 
             state.type = _type;
             state.channel = _channel;
         }
         finally {
         }
     }
     // $ANTLR end "LOWERCASE"
 
     // $ANTLR start "UPPERCASE"
     public final void mUPPERCASE() throws RecognitionException {
         try {
             // BooleanFunction.g:77:20: ( 'A' .. 'Z' )
             // BooleanFunction.g:77:22: 'A' .. 'Z'
             {
             matchRange('A','Z');
 
             }
 
         }
         finally {
         }
     }
     // $ANTLR end "UPPERCASE"
 
     public void mTokens() throws RecognitionException {
         // BooleanFunction.g:1:8: ( OR | AND | LP | RP | ALPHA | NUMBER | WHITESPACE | LOWERCASE )
         int alt4=8;
         switch ( input.LA(1) ) {
         case '+':
             {
             alt4=1;
             }
             break;
         case '*':
             {
             alt4=2;
             }
             break;
         case '(':
             {
             alt4=3;
             }
             break;
         case ')':
             {
             alt4=4;
             }
             break;
         case 'A':
         case 'B':
         case 'C':
         case 'D':
         case 'E':
         case 'F':
         case 'G':
         case 'H':
         case 'I':
         case 'J':
         case 'K':
         case 'L':
         case 'M':
         case 'N':
         case 'O':
         case 'P':
         case 'Q':
         case 'R':
         case 'S':
         case 'T':
         case 'U':
         case 'V':
         case 'W':
         case 'X':
         case 'Y':
         case 'Z':
             {
             alt4=5;
             }
             break;
         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
         case '8':
         case '9':
             {
             alt4=6;
             }
             break;
         case '\t':
         case '\n':
         case '\f':
         case '\r':
         case ' ':
             {
             alt4=7;
             }
             break;
         case 'a':
         case 'b':
         case 'c':
         case 'd':
         case 'e':
         case 'f':
         case 'g':
         case 'h':
         case 'i':
         case 'j':
         case 'k':
         case 'l':
         case 'm':
         case 'n':
         case 'o':
         case 'p':
         case 'q':
         case 'r':
         case 's':
         case 't':
         case 'u':
         case 'v':
         case 'w':
         case 'x':
         case 'y':
         case 'z':
             {
             alt4=8;
             }
             break;
         default:
             NoViableAltException nvae =
                 new NoViableAltException("", 4, 0, input);
 
             throw nvae;
         }
 
         switch (alt4) {
             case 1 :
                 // BooleanFunction.g:1:10: OR
                 {
                 mOR();
 
                 }
                 break;
             case 2 :
                 // BooleanFunction.g:1:13: AND
                 {
                 mAND();
 
                 }
                 break;
             case 3 :
                 // BooleanFunction.g:1:17: LP
                 {
                 mLP();
 
                 }
                 break;
             case 4 :
                 // BooleanFunction.g:1:20: RP
                 {
                 mRP();
 
                 }
                 break;
             case 5 :
                 // BooleanFunction.g:1:23: ALPHA
                 {
                 mALPHA();
 
                 }
                 break;
             case 6 :
                 // BooleanFunction.g:1:29: NUMBER
                 {
                 mNUMBER();
 
                 }
                 break;
             case 7 :
                 // BooleanFunction.g:1:36: WHITESPACE
                 {
                 mWHITESPACE();
 
                 }
                 break;
             case 8 :
                 // BooleanFunction.g:1:47: LOWERCASE
                 {
                 mLOWERCASE();
 
                 }
                 break;
 
         }
 
     }
 
 
 
 
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		// $ANTLR 3.1.1 BooleanFunction.g 2009-06-03 01:05:39
17		package org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers;
18
19		import org.antlr.runtime.CharStream;
20		import org.antlr.runtime.EarlyExitException;
21		import org.antlr.runtime.Lexer;
22		import org.antlr.runtime.MismatchedSetException;
23		import org.antlr.runtime.NoViableAltException;
24		import org.antlr.runtime.RecognitionException;
25		import org.antlr.runtime.RecognizerSharedState;
26
27		public class BooleanFunctionLexer extends Lexer {
28		public static final int UPPERCASE=9;
29		public static final int LOWERCASE=12;
30		public static final int RP=7;
31		public static final int OR=4;
32		public static final int LP=6;
33		public static final int NUMBER=10;
34		public static final int WHITESPACE=11;
35		public static final int AND=5;
36		public static final int EOF=-1;
37		public static final int ALPHA=8;
38
39		// delegates
40		// delegators
41
42	0	public BooleanFunctionLexer() {;}
43		public BooleanFunctionLexer(CharStream input) {
44	46	this(input, new RecognizerSharedState());
45	46	}
46		public BooleanFunctionLexer(CharStream input, RecognizerSharedState state) {
47	46	super(input,state);
48
49	46	}
50	0	public String getGrammarFileName() { return "BooleanFunction.g"; }
51
52		// $ANTLR start "OR"
53		public final void mOR() throws RecognitionException {
54		try {
55	42	int _type = OR;
56	42	int _channel = DEFAULT_TOKEN_CHANNEL;
57		// BooleanFunction.g:5:4: ( '+' )
58		// BooleanFunction.g:5:6: '+'
59		{
60	42	match('+');
61
62		}
63
64	42	state.type = _type;
65	42	state.channel = _channel;
66		}
67	0	finally {
68	42	}
69	42	}
70		// $ANTLR end "OR"
71
72		// $ANTLR start "AND"
73		public final void mAND() throws RecognitionException {
74		try {
75	67	int _type = AND;
76	67	int _channel = DEFAULT_TOKEN_CHANNEL;
77		// BooleanFunction.g:6:5: ( '*' )
78		// BooleanFunction.g:6:7: '*'
79		{
80	67	match('*');
81
82		}
83
84	67	state.type = _type;
85	67	state.channel = _channel;
86		}
87	0	finally {
88	67	}
89	67	}
90		// $ANTLR end "AND"
91
92		// $ANTLR start "LP"
93		public final void mLP() throws RecognitionException {
94		try {
95	44	int _type = LP;
96	44	int _channel = DEFAULT_TOKEN_CHANNEL;
97		// BooleanFunction.g:7:4: ( '(' )
98		// BooleanFunction.g:7:6: '('
99		{
100	44	match('(');
101
102		}
103
104	44	state.type = _type;
105	44	state.channel = _channel;
106		}
107	0	finally {
108	44	}
109	44	}
110		// $ANTLR end "LP"
111
112		// $ANTLR start "RP"
113		public final void mRP() throws RecognitionException {
114		try {
115	44	int _type = RP;
116	44	int _channel = DEFAULT_TOKEN_CHANNEL;
117		// BooleanFunction.g:8:4: ( ')' )
118		// BooleanFunction.g:8:6: ')'
119		{
120	44	match(')');
121
122		}
123
124	44	state.type = _type;
125	44	state.channel = _channel;
126		}
127	0	finally {
128	44	}
129	44	}
130		// $ANTLR end "RP"
131
132		// $ANTLR start "ALPHA"
133		public final void mALPHA() throws RecognitionException {
134		try {
135	153	int _type = ALPHA;
136	153	int _channel = DEFAULT_TOKEN_CHANNEL;
137		// BooleanFunction.g:69:9: ( UPPERCASE \| ( UPPERCASE NUMBER ) )
138	153	int alt1=2;
139	153	int LA1_0 = input.LA(1);
140
141	153	if ( ((LA1_0>='A' && LA1_0<='Z')) ) {
142	153	int LA1_1 = input.LA(2);
143
144	153	if ( ((LA1_1>='0' && LA1_1<='9')) ) {
145	77	alt1=2;
146		}
147		else {
148	76	alt1=1;}
149	153	}
150		else {
151	0	NoViableAltException nvae =
152		new NoViableAltException("", 1, 0, input);
153
154	0	throw nvae;
155		}
156	153	switch (alt1) {
157		case 1 :
158		// BooleanFunction.g:69:11: UPPERCASE
159		{
160	76	mUPPERCASE();
161
162		}
163	76	break;
164		case 2 :
165		// BooleanFunction.g:69:23: ( UPPERCASE NUMBER )
166		{
167		// BooleanFunction.g:69:23: ( UPPERCASE NUMBER )
168		// BooleanFunction.g:69:24: UPPERCASE NUMBER
169		{
170	77	mUPPERCASE();
171	77	mNUMBER();
172
173		}
174
175
176		}
177		break;
178
179		}
180	153	state.type = _type;
181	153	state.channel = _channel;
182		}
183	0	finally {
184	153	}
185	153	}
186		// $ANTLR end "ALPHA"
187
188		// $ANTLR start "NUMBER"
189		public final void mNUMBER() throws RecognitionException {
190		try {
191	77	int _type = NUMBER;
192	77	int _channel = DEFAULT_TOKEN_CHANNEL;
193		// BooleanFunction.g:71:9: ( ( '0' .. '9' )+ )
194		// BooleanFunction.g:71:11: ( '0' .. '9' )+
195		{
196		// BooleanFunction.g:71:11: ( '0' .. '9' )+
197	77	int cnt2=0;
198		loop2:
199		do {
200	154	int alt2=2;
201	154	int LA2_0 = input.LA(1);
202
203	154	if ( ((LA2_0>='0' && LA2_0<='9')) ) {
204	77	alt2=1;
205		}
206
207
208	154	switch (alt2) {
209		case 1 :
210		// BooleanFunction.g:71:12: '0' .. '9'
211		{
212	77	matchRange('0','9');
213
214		}
215	77	break;
216
217		default :
218	77	if ( cnt2 >= 1 ) break loop2;
219	0	EarlyExitException eee =
220		new EarlyExitException(2, input);
221	0	throw eee;
222		}
223	77	cnt2++;
224	77	} while (true);
225
226
227		}
228
229	77	state.type = _type;
230	77	state.channel = _channel;
231		}
232	0	finally {
233	77	}
234	77	}
235		// $ANTLR end "NUMBER"
236
237		// $ANTLR start "WHITESPACE"
238		public final void mWHITESPACE() throws RecognitionException {
239		try {
240	0	int _type = WHITESPACE;
241	0	int _channel = DEFAULT_TOKEN_CHANNEL;
242		// BooleanFunction.g:73:12: ( ( '\\t' \| ' ' \| '\\r' \| '\\n' \| '\\u000C' )+ )
243		// BooleanFunction.g:73:14: ( '\\t' \| ' ' \| '\\r' \| '\\n' \| '\\u000C' )+
244		{
245		// BooleanFunction.g:73:14: ( '\\t' \| ' ' \| '\\r' \| '\\n' \| '\\u000C' )+
246	0	int cnt3=0;
247		loop3:
248		do {
249	0	int alt3=2;
250	0	int LA3_0 = input.LA(1);
251
252	0	if ( ((LA3_0>='\t' && LA3_0<='\n')\|\|(LA3_0>='\f' && LA3_0<='\r')\|\|LA3_0==' ') ) {
253	0	alt3=1;
254		}
255
256
257	0	switch (alt3) {
258		case 1 :
259		// BooleanFunction.g:
260		{
261	0	if ( (input.LA(1)>='\t' && input.LA(1)<='\n')\|\|(input.LA(1)>='\f' && input.LA(1)<='\r')\|\|input.LA(1)==' ' ) {
262	0	input.consume();
263
264		}
265		else {
266	0	MismatchedSetException mse = new MismatchedSetException(null,input);
267	0	recover(mse);
268	0	throw mse;}
269
270
271		}
272		break;
273
274		default :
275	0	if ( cnt3 >= 1 ) break loop3;
276	0	EarlyExitException eee =
277		new EarlyExitException(3, input);
278	0	throw eee;
279		}
280	0	cnt3++;
281	0	} while (true);
282
283	0	_channel = HIDDEN;
284
285		}
286
287	0	state.type = _type;
288	0	state.channel = _channel;
289		}
290	0	finally {
291	0	}
292	0	}
293		// $ANTLR end "WHITESPACE"
294
295		// $ANTLR start "LOWERCASE"
296		public final void mLOWERCASE() throws RecognitionException {
297		try {
298	0	int _type = LOWERCASE;
299	0	int _channel = DEFAULT_TOKEN_CHANNEL;
300		// BooleanFunction.g:75:11: ( 'a' .. 'z' )
301		// BooleanFunction.g:75:13: 'a' .. 'z'
302		{
303	0	matchRange('a','z');
304
305		}
306
307	0	state.type = _type;
308	0	state.channel = _channel;
309		}
310	0	finally {
311	0	}
312	0	}
313		// $ANTLR end "LOWERCASE"
314
315		// $ANTLR start "UPPERCASE"
316		public final void mUPPERCASE() throws RecognitionException {
317		try {
318		// BooleanFunction.g:77:20: ( 'A' .. 'Z' )
319		// BooleanFunction.g:77:22: 'A' .. 'Z'
320		{
321	153	matchRange('A','Z');
322
323		}
324
325		}
326	0	finally {
327	153	}
328	153	}
329		// $ANTLR end "UPPERCASE"
330
331		public void mTokens() throws RecognitionException {
332		// BooleanFunction.g:1:8: ( OR \| AND \| LP \| RP \| ALPHA \| NUMBER \| WHITESPACE \| LOWERCASE )
333	350	int alt4=8;
334	350	switch ( input.LA(1) ) {
335		case '+':
336		{
337	42	alt4=1;
338		}
339	42	break;
340		case '*':
341		{
342	67	alt4=2;
343		}
344	67	break;
345		case '(':
346		{
347	44	alt4=3;
348		}
349	44	break;
350		case ')':
351		{
352	44	alt4=4;
353		}
354	44	break;
355		case 'A':
356		case 'B':
357		case 'C':
358		case 'D':
359		case 'E':
360		case 'F':
361		case 'G':
362		case 'H':
363		case 'I':
364		case 'J':
365		case 'K':
366		case 'L':
367		case 'M':
368		case 'N':
369		case 'O':
370		case 'P':
371		case 'Q':
372		case 'R':
373		case 'S':
374		case 'T':
375		case 'U':
376		case 'V':
377		case 'W':
378		case 'X':
379		case 'Y':
380		case 'Z':
381		{
382	153	alt4=5;
383		}
384	153	break;
385		case '0':
386		case '1':
387		case '2':
388		case '3':
389		case '4':
390		case '5':
391		case '6':
392		case '7':
393		case '8':
394		case '9':
395		{
396	0	alt4=6;
397		}
398	0	break;
399		case '\t':
400		case '\n':
401		case '\f':
402		case '\r':
403		case ' ':
404		{
405	0	alt4=7;
406		}
407	0	break;
408		case 'a':
409		case 'b':
410		case 'c':
411		case 'd':
412		case 'e':
413		case 'f':
414		case 'g':
415		case 'h':
416		case 'i':
417		case 'j':
418		case 'k':
419		case 'l':
420		case 'm':
421		case 'n':
422		case 'o':
423		case 'p':
424		case 'q':
425		case 'r':
426		case 's':
427		case 't':
428		case 'u':
429		case 'v':
430		case 'w':
431		case 'x':
432		case 'y':
433		case 'z':
434		{
435	0	alt4=8;
436		}
437	0	break;
438		default:
439	0	NoViableAltException nvae =
440		new NoViableAltException("", 4, 0, input);
441
442	0	throw nvae;
443		}
444
445	350	switch (alt4) {
446		case 1 :
447		// BooleanFunction.g:1:10: OR
448		{
449	42	mOR();
450
451		}
452	42	break;
453		case 2 :
454		// BooleanFunction.g:1:13: AND
455		{
456	67	mAND();
457
458		}
459	67	break;
460		case 3 :
461		// BooleanFunction.g:1:17: LP
462		{
463	44	mLP();
464
465		}
466	44	break;
467		case 4 :
468		// BooleanFunction.g:1:20: RP
469		{
470	44	mRP();
471
472		}
473	44	break;
474		case 5 :
475		// BooleanFunction.g:1:23: ALPHA
476		{
477	153	mALPHA();
478
479		}
480	153	break;
481		case 6 :
482		// BooleanFunction.g:1:29: NUMBER
483		{
484	0	mNUMBER();
485
486		}
487	0	break;
488		case 7 :
489		// BooleanFunction.g:1:36: WHITESPACE
490		{
491	0	mWHITESPACE();
492
493		}
494	0	break;
495		case 8 :
496		// BooleanFunction.g:1:47: LOWERCASE
497		{
498	0	mLOWERCASE();
499
500		}
501		break;
502
503		}
504
505	350	}
506
507
508
509
510		}