mirror of https://github.com/Minres/RDL-Editor.git
5284 lines
148 KiB
Java
5284 lines
148 KiB
Java
package com.minres.rdl.ide.contentassist.antlr.internal;
|
|
|
|
// Hack: Use our own Lexer superclass by means of import.
|
|
// Currently there is no other way to specify the superclass for the lexer.
|
|
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
|
|
|
|
|
|
import org.antlr.runtime.*;
|
|
import java.util.Stack;
|
|
import java.util.List;
|
|
import java.util.ArrayList;
|
|
|
|
@SuppressWarnings("all")
|
|
public class InternalRDLLexer extends Lexer {
|
|
public static final int T__50=50;
|
|
public static final int T__59=59;
|
|
public static final int T__55=55;
|
|
public static final int T__56=56;
|
|
public static final int T__57=57;
|
|
public static final int T__58=58;
|
|
public static final int T__51=51;
|
|
public static final int T__52=52;
|
|
public static final int T__53=53;
|
|
public static final int T__54=54;
|
|
public static final int T__132=132;
|
|
public static final int T__60=60;
|
|
public static final int T__61=61;
|
|
public static final int RULE_ID=5;
|
|
public static final int T__131=131;
|
|
public static final int T__130=130;
|
|
public static final int T__66=66;
|
|
public static final int RULE_ML_COMMENT=8;
|
|
public static final int T__67=67;
|
|
public static final int T__129=129;
|
|
public static final int T__68=68;
|
|
public static final int T__69=69;
|
|
public static final int T__62=62;
|
|
public static final int T__126=126;
|
|
public static final int T__63=63;
|
|
public static final int T__125=125;
|
|
public static final int T__64=64;
|
|
public static final int T__128=128;
|
|
public static final int T__65=65;
|
|
public static final int T__127=127;
|
|
public static final int T__37=37;
|
|
public static final int T__38=38;
|
|
public static final int T__39=39;
|
|
public static final int T__33=33;
|
|
public static final int T__34=34;
|
|
public static final int T__35=35;
|
|
public static final int T__36=36;
|
|
public static final int T__30=30;
|
|
public static final int T__31=31;
|
|
public static final int T__32=32;
|
|
public static final int T__48=48;
|
|
public static final int T__49=49;
|
|
public static final int RULE_STR=4;
|
|
public static final int T__44=44;
|
|
public static final int T__45=45;
|
|
public static final int T__46=46;
|
|
public static final int T__47=47;
|
|
public static final int T__40=40;
|
|
public static final int T__41=41;
|
|
public static final int T__42=42;
|
|
public static final int T__43=43;
|
|
public static final int T__91=91;
|
|
public static final int T__100=100;
|
|
public static final int T__92=92;
|
|
public static final int T__93=93;
|
|
public static final int T__102=102;
|
|
public static final int T__94=94;
|
|
public static final int T__101=101;
|
|
public static final int T__90=90;
|
|
public static final int T__19=19;
|
|
public static final int T__15=15;
|
|
public static final int T__16=16;
|
|
public static final int T__17=17;
|
|
public static final int T__18=18;
|
|
public static final int T__11=11;
|
|
public static final int T__99=99;
|
|
public static final int RULE_NUM=6;
|
|
public static final int T__12=12;
|
|
public static final int T__13=13;
|
|
public static final int T__14=14;
|
|
public static final int T__95=95;
|
|
public static final int T__96=96;
|
|
public static final int T__97=97;
|
|
public static final int T__10=10;
|
|
public static final int T__98=98;
|
|
public static final int T__26=26;
|
|
public static final int T__27=27;
|
|
public static final int T__28=28;
|
|
public static final int T__29=29;
|
|
public static final int T__22=22;
|
|
public static final int T__23=23;
|
|
public static final int T__24=24;
|
|
public static final int T__25=25;
|
|
public static final int T__20=20;
|
|
public static final int T__21=21;
|
|
public static final int T__122=122;
|
|
public static final int T__70=70;
|
|
public static final int T__121=121;
|
|
public static final int T__71=71;
|
|
public static final int T__124=124;
|
|
public static final int T__72=72;
|
|
public static final int T__123=123;
|
|
public static final int T__120=120;
|
|
public static final int RULE_SL_COMMENT=9;
|
|
public static final int T__77=77;
|
|
public static final int T__119=119;
|
|
public static final int T__78=78;
|
|
public static final int T__118=118;
|
|
public static final int T__79=79;
|
|
public static final int T__73=73;
|
|
public static final int T__115=115;
|
|
public static final int EOF=-1;
|
|
public static final int T__74=74;
|
|
public static final int T__114=114;
|
|
public static final int T__75=75;
|
|
public static final int T__117=117;
|
|
public static final int T__76=76;
|
|
public static final int T__116=116;
|
|
public static final int T__80=80;
|
|
public static final int T__111=111;
|
|
public static final int T__81=81;
|
|
public static final int T__110=110;
|
|
public static final int T__82=82;
|
|
public static final int T__113=113;
|
|
public static final int T__83=83;
|
|
public static final int T__112=112;
|
|
public static final int RULE_WS=7;
|
|
public static final int T__88=88;
|
|
public static final int T__108=108;
|
|
public static final int T__89=89;
|
|
public static final int T__107=107;
|
|
public static final int T__109=109;
|
|
public static final int T__84=84;
|
|
public static final int T__104=104;
|
|
public static final int T__85=85;
|
|
public static final int T__103=103;
|
|
public static final int T__86=86;
|
|
public static final int T__106=106;
|
|
public static final int T__87=87;
|
|
public static final int T__105=105;
|
|
|
|
// delegates
|
|
// delegators
|
|
|
|
public InternalRDLLexer() {;}
|
|
public InternalRDLLexer(CharStream input) {
|
|
this(input, new RecognizerSharedState());
|
|
}
|
|
public InternalRDLLexer(CharStream input, RecognizerSharedState state) {
|
|
super(input,state);
|
|
|
|
}
|
|
public String getGrammarFileName() { return "InternalRDL.g"; }
|
|
|
|
// $ANTLR start "T__10"
|
|
public final void mT__10() throws RecognitionException {
|
|
try {
|
|
int _type = T__10;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:11:7: ( 'string' )
|
|
// InternalRDL.g:11:9: 'string'
|
|
{
|
|
match("string");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__10"
|
|
|
|
// $ANTLR start "T__11"
|
|
public final void mT__11() throws RecognitionException {
|
|
try {
|
|
int _type = T__11;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:12:7: ( 'number' )
|
|
// InternalRDL.g:12:9: 'number'
|
|
{
|
|
match("number");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__11"
|
|
|
|
// $ANTLR start "T__12"
|
|
public final void mT__12() throws RecognitionException {
|
|
try {
|
|
int _type = T__12;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:13:7: ( 'boolean' )
|
|
// InternalRDL.g:13:9: 'boolean'
|
|
{
|
|
match("boolean");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__12"
|
|
|
|
// $ANTLR start "T__13"
|
|
public final void mT__13() throws RecognitionException {
|
|
try {
|
|
int _type = T__13;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:14:7: ( 'addrmap' )
|
|
// InternalRDL.g:14:9: 'addrmap'
|
|
{
|
|
match("addrmap");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__13"
|
|
|
|
// $ANTLR start "T__14"
|
|
public final void mT__14() throws RecognitionException {
|
|
try {
|
|
int _type = T__14;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:15:7: ( 'reg' )
|
|
// InternalRDL.g:15:9: 'reg'
|
|
{
|
|
match("reg");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__14"
|
|
|
|
// $ANTLR start "T__15"
|
|
public final void mT__15() throws RecognitionException {
|
|
try {
|
|
int _type = T__15;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:16:7: ( 'regfile' )
|
|
// InternalRDL.g:16:9: 'regfile'
|
|
{
|
|
match("regfile");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__15"
|
|
|
|
// $ANTLR start "T__16"
|
|
public final void mT__16() throws RecognitionException {
|
|
try {
|
|
int _type = T__16;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:17:7: ( 'field' )
|
|
// InternalRDL.g:17:9: 'field'
|
|
{
|
|
match("field");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__16"
|
|
|
|
// $ANTLR start "T__17"
|
|
public final void mT__17() throws RecognitionException {
|
|
try {
|
|
int _type = T__17;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:18:7: ( 'ref' )
|
|
// InternalRDL.g:18:9: 'ref'
|
|
{
|
|
match("ref");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__17"
|
|
|
|
// $ANTLR start "T__18"
|
|
public final void mT__18() throws RecognitionException {
|
|
try {
|
|
int _type = T__18;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:19:7: ( 'signal' )
|
|
// InternalRDL.g:19:9: 'signal'
|
|
{
|
|
match("signal");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__18"
|
|
|
|
// $ANTLR start "T__19"
|
|
public final void mT__19() throws RecognitionException {
|
|
try {
|
|
int _type = T__19;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:20:7: ( 'all' )
|
|
// InternalRDL.g:20:9: 'all'
|
|
{
|
|
match("all");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__19"
|
|
|
|
// $ANTLR start "T__20"
|
|
public final void mT__20() throws RecognitionException {
|
|
try {
|
|
int _type = T__20;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:21:7: ( 'name' )
|
|
// InternalRDL.g:21:9: 'name'
|
|
{
|
|
match("name");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__20"
|
|
|
|
// $ANTLR start "T__21"
|
|
public final void mT__21() throws RecognitionException {
|
|
try {
|
|
int _type = T__21;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:22:7: ( 'desc' )
|
|
// InternalRDL.g:22:9: 'desc'
|
|
{
|
|
match("desc");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__21"
|
|
|
|
// $ANTLR start "T__22"
|
|
public final void mT__22() throws RecognitionException {
|
|
try {
|
|
int _type = T__22;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:23:7: ( 'arbiter' )
|
|
// InternalRDL.g:23:9: 'arbiter'
|
|
{
|
|
match("arbiter");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__22"
|
|
|
|
// $ANTLR start "T__23"
|
|
public final void mT__23() throws RecognitionException {
|
|
try {
|
|
int _type = T__23;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:24:7: ( 'rset' )
|
|
// InternalRDL.g:24:9: 'rset'
|
|
{
|
|
match("rset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__23"
|
|
|
|
// $ANTLR start "T__24"
|
|
public final void mT__24() throws RecognitionException {
|
|
try {
|
|
int _type = T__24;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:25:7: ( 'rclr' )
|
|
// InternalRDL.g:25:9: 'rclr'
|
|
{
|
|
match("rclr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__24"
|
|
|
|
// $ANTLR start "T__25"
|
|
public final void mT__25() throws RecognitionException {
|
|
try {
|
|
int _type = T__25;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:26:7: ( 'woclr' )
|
|
// InternalRDL.g:26:9: 'woclr'
|
|
{
|
|
match("woclr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__25"
|
|
|
|
// $ANTLR start "T__26"
|
|
public final void mT__26() throws RecognitionException {
|
|
try {
|
|
int _type = T__26;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:27:7: ( 'woset' )
|
|
// InternalRDL.g:27:9: 'woset'
|
|
{
|
|
match("woset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__26"
|
|
|
|
// $ANTLR start "T__27"
|
|
public final void mT__27() throws RecognitionException {
|
|
try {
|
|
int _type = T__27;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:28:7: ( 'we' )
|
|
// InternalRDL.g:28:9: 'we'
|
|
{
|
|
match("we");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__27"
|
|
|
|
// $ANTLR start "T__28"
|
|
public final void mT__28() throws RecognitionException {
|
|
try {
|
|
int _type = T__28;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:29:7: ( 'wel' )
|
|
// InternalRDL.g:29:9: 'wel'
|
|
{
|
|
match("wel");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__28"
|
|
|
|
// $ANTLR start "T__29"
|
|
public final void mT__29() throws RecognitionException {
|
|
try {
|
|
int _type = T__29;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:30:7: ( 'swwe' )
|
|
// InternalRDL.g:30:9: 'swwe'
|
|
{
|
|
match("swwe");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__29"
|
|
|
|
// $ANTLR start "T__30"
|
|
public final void mT__30() throws RecognitionException {
|
|
try {
|
|
int _type = T__30;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:31:7: ( 'swwel' )
|
|
// InternalRDL.g:31:9: 'swwel'
|
|
{
|
|
match("swwel");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__30"
|
|
|
|
// $ANTLR start "T__31"
|
|
public final void mT__31() throws RecognitionException {
|
|
try {
|
|
int _type = T__31;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:32:7: ( 'hwset' )
|
|
// InternalRDL.g:32:9: 'hwset'
|
|
{
|
|
match("hwset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__31"
|
|
|
|
// $ANTLR start "T__32"
|
|
public final void mT__32() throws RecognitionException {
|
|
try {
|
|
int _type = T__32;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:33:7: ( 'hwclr' )
|
|
// InternalRDL.g:33:9: 'hwclr'
|
|
{
|
|
match("hwclr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__32"
|
|
|
|
// $ANTLR start "T__33"
|
|
public final void mT__33() throws RecognitionException {
|
|
try {
|
|
int _type = T__33;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:34:7: ( 'swmod' )
|
|
// InternalRDL.g:34:9: 'swmod'
|
|
{
|
|
match("swmod");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__33"
|
|
|
|
// $ANTLR start "T__34"
|
|
public final void mT__34() throws RecognitionException {
|
|
try {
|
|
int _type = T__34;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:35:7: ( 'swacc' )
|
|
// InternalRDL.g:35:9: 'swacc'
|
|
{
|
|
match("swacc");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__34"
|
|
|
|
// $ANTLR start "T__35"
|
|
public final void mT__35() throws RecognitionException {
|
|
try {
|
|
int _type = T__35;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:36:7: ( 'sticky' )
|
|
// InternalRDL.g:36:9: 'sticky'
|
|
{
|
|
match("sticky");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__35"
|
|
|
|
// $ANTLR start "T__36"
|
|
public final void mT__36() throws RecognitionException {
|
|
try {
|
|
int _type = T__36;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:37:7: ( 'stickybit' )
|
|
// InternalRDL.g:37:9: 'stickybit'
|
|
{
|
|
match("stickybit");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__36"
|
|
|
|
// $ANTLR start "T__37"
|
|
public final void mT__37() throws RecognitionException {
|
|
try {
|
|
int _type = T__37;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:38:7: ( 'intr' )
|
|
// InternalRDL.g:38:9: 'intr'
|
|
{
|
|
match("intr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__37"
|
|
|
|
// $ANTLR start "T__38"
|
|
public final void mT__38() throws RecognitionException {
|
|
try {
|
|
int _type = T__38;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:39:7: ( 'anded' )
|
|
// InternalRDL.g:39:9: 'anded'
|
|
{
|
|
match("anded");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__38"
|
|
|
|
// $ANTLR start "T__39"
|
|
public final void mT__39() throws RecognitionException {
|
|
try {
|
|
int _type = T__39;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:40:7: ( 'ored' )
|
|
// InternalRDL.g:40:9: 'ored'
|
|
{
|
|
match("ored");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__39"
|
|
|
|
// $ANTLR start "T__40"
|
|
public final void mT__40() throws RecognitionException {
|
|
try {
|
|
int _type = T__40;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:41:7: ( 'xored' )
|
|
// InternalRDL.g:41:9: 'xored'
|
|
{
|
|
match("xored");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__40"
|
|
|
|
// $ANTLR start "T__41"
|
|
public final void mT__41() throws RecognitionException {
|
|
try {
|
|
int _type = T__41;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:42:7: ( 'counter' )
|
|
// InternalRDL.g:42:9: 'counter'
|
|
{
|
|
match("counter");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__41"
|
|
|
|
// $ANTLR start "T__42"
|
|
public final void mT__42() throws RecognitionException {
|
|
try {
|
|
int _type = T__42;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:43:7: ( 'overflow' )
|
|
// InternalRDL.g:43:9: 'overflow'
|
|
{
|
|
match("overflow");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__42"
|
|
|
|
// $ANTLR start "T__43"
|
|
public final void mT__43() throws RecognitionException {
|
|
try {
|
|
int _type = T__43;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:44:7: ( 'sharedextbus' )
|
|
// InternalRDL.g:44:9: 'sharedextbus'
|
|
{
|
|
match("sharedextbus");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__43"
|
|
|
|
// $ANTLR start "T__44"
|
|
public final void mT__44() throws RecognitionException {
|
|
try {
|
|
int _type = T__44;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:45:7: ( 'errextbus' )
|
|
// InternalRDL.g:45:9: 'errextbus'
|
|
{
|
|
match("errextbus");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__44"
|
|
|
|
// $ANTLR start "T__45"
|
|
public final void mT__45() throws RecognitionException {
|
|
try {
|
|
int _type = T__45;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:46:7: ( 'reset' )
|
|
// InternalRDL.g:46:9: 'reset'
|
|
{
|
|
match("reset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__45"
|
|
|
|
// $ANTLR start "T__46"
|
|
public final void mT__46() throws RecognitionException {
|
|
try {
|
|
int _type = T__46;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:47:7: ( 'littleendian' )
|
|
// InternalRDL.g:47:9: 'littleendian'
|
|
{
|
|
match("littleendian");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__46"
|
|
|
|
// $ANTLR start "T__47"
|
|
public final void mT__47() throws RecognitionException {
|
|
try {
|
|
int _type = T__47;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:48:7: ( 'bigendian' )
|
|
// InternalRDL.g:48:9: 'bigendian'
|
|
{
|
|
match("bigendian");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__47"
|
|
|
|
// $ANTLR start "T__48"
|
|
public final void mT__48() throws RecognitionException {
|
|
try {
|
|
int _type = T__48;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:49:7: ( 'rsvdset' )
|
|
// InternalRDL.g:49:9: 'rsvdset'
|
|
{
|
|
match("rsvdset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__48"
|
|
|
|
// $ANTLR start "T__49"
|
|
public final void mT__49() throws RecognitionException {
|
|
try {
|
|
int _type = T__49;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:50:7: ( 'rsvdsetX' )
|
|
// InternalRDL.g:50:9: 'rsvdsetX'
|
|
{
|
|
match("rsvdsetX");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__49"
|
|
|
|
// $ANTLR start "T__50"
|
|
public final void mT__50() throws RecognitionException {
|
|
try {
|
|
int _type = T__50;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:51:7: ( 'bridge' )
|
|
// InternalRDL.g:51:9: 'bridge'
|
|
{
|
|
match("bridge");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__50"
|
|
|
|
// $ANTLR start "T__51"
|
|
public final void mT__51() throws RecognitionException {
|
|
try {
|
|
int _type = T__51;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:52:7: ( 'shared' )
|
|
// InternalRDL.g:52:9: 'shared'
|
|
{
|
|
match("shared");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__51"
|
|
|
|
// $ANTLR start "T__52"
|
|
public final void mT__52() throws RecognitionException {
|
|
try {
|
|
int _type = T__52;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:53:7: ( 'msb0' )
|
|
// InternalRDL.g:53:9: 'msb0'
|
|
{
|
|
match("msb0");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__52"
|
|
|
|
// $ANTLR start "T__53"
|
|
public final void mT__53() throws RecognitionException {
|
|
try {
|
|
int _type = T__53;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:54:7: ( 'lsb0' )
|
|
// InternalRDL.g:54:9: 'lsb0'
|
|
{
|
|
match("lsb0");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__53"
|
|
|
|
// $ANTLR start "T__54"
|
|
public final void mT__54() throws RecognitionException {
|
|
try {
|
|
int _type = T__54;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:55:7: ( 'sync' )
|
|
// InternalRDL.g:55:9: 'sync'
|
|
{
|
|
match("sync");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__54"
|
|
|
|
// $ANTLR start "T__55"
|
|
public final void mT__55() throws RecognitionException {
|
|
try {
|
|
int _type = T__55;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:56:7: ( 'async' )
|
|
// InternalRDL.g:56:9: 'async'
|
|
{
|
|
match("async");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__55"
|
|
|
|
// $ANTLR start "T__56"
|
|
public final void mT__56() throws RecognitionException {
|
|
try {
|
|
int _type = T__56;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:57:7: ( 'cpuif_reset' )
|
|
// InternalRDL.g:57:9: 'cpuif_reset'
|
|
{
|
|
match("cpuif_reset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__56"
|
|
|
|
// $ANTLR start "T__57"
|
|
public final void mT__57() throws RecognitionException {
|
|
try {
|
|
int _type = T__57;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:58:7: ( 'field_reset' )
|
|
// InternalRDL.g:58:9: 'field_reset'
|
|
{
|
|
match("field_reset");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__57"
|
|
|
|
// $ANTLR start "T__58"
|
|
public final void mT__58() throws RecognitionException {
|
|
try {
|
|
int _type = T__58;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:59:7: ( 'activehigh' )
|
|
// InternalRDL.g:59:9: 'activehigh'
|
|
{
|
|
match("activehigh");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__58"
|
|
|
|
// $ANTLR start "T__59"
|
|
public final void mT__59() throws RecognitionException {
|
|
try {
|
|
int _type = T__59;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:60:7: ( 'activelow' )
|
|
// InternalRDL.g:60:9: 'activelow'
|
|
{
|
|
match("activelow");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__59"
|
|
|
|
// $ANTLR start "T__60"
|
|
public final void mT__60() throws RecognitionException {
|
|
try {
|
|
int _type = T__60;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:61:7: ( 'singlepulse' )
|
|
// InternalRDL.g:61:9: 'singlepulse'
|
|
{
|
|
match("singlepulse");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__60"
|
|
|
|
// $ANTLR start "T__61"
|
|
public final void mT__61() throws RecognitionException {
|
|
try {
|
|
int _type = T__61;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:62:7: ( 'underflow' )
|
|
// InternalRDL.g:62:9: 'underflow'
|
|
{
|
|
match("underflow");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__61"
|
|
|
|
// $ANTLR start "T__62"
|
|
public final void mT__62() throws RecognitionException {
|
|
try {
|
|
int _type = T__62;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:63:7: ( 'incr' )
|
|
// InternalRDL.g:63:9: 'incr'
|
|
{
|
|
match("incr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__62"
|
|
|
|
// $ANTLR start "T__63"
|
|
public final void mT__63() throws RecognitionException {
|
|
try {
|
|
int _type = T__63;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:64:7: ( 'decr' )
|
|
// InternalRDL.g:64:9: 'decr'
|
|
{
|
|
match("decr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__63"
|
|
|
|
// $ANTLR start "T__64"
|
|
public final void mT__64() throws RecognitionException {
|
|
try {
|
|
int _type = T__64;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:65:7: ( 'incrwidth' )
|
|
// InternalRDL.g:65:9: 'incrwidth'
|
|
{
|
|
match("incrwidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__64"
|
|
|
|
// $ANTLR start "T__65"
|
|
public final void mT__65() throws RecognitionException {
|
|
try {
|
|
int _type = T__65;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:66:7: ( 'decrwidth' )
|
|
// InternalRDL.g:66:9: 'decrwidth'
|
|
{
|
|
match("decrwidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__65"
|
|
|
|
// $ANTLR start "T__66"
|
|
public final void mT__66() throws RecognitionException {
|
|
try {
|
|
int _type = T__66;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:67:7: ( 'incrvalue' )
|
|
// InternalRDL.g:67:9: 'incrvalue'
|
|
{
|
|
match("incrvalue");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__66"
|
|
|
|
// $ANTLR start "T__67"
|
|
public final void mT__67() throws RecognitionException {
|
|
try {
|
|
int _type = T__67;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:68:7: ( 'decrvalue' )
|
|
// InternalRDL.g:68:9: 'decrvalue'
|
|
{
|
|
match("decrvalue");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__67"
|
|
|
|
// $ANTLR start "T__68"
|
|
public final void mT__68() throws RecognitionException {
|
|
try {
|
|
int _type = T__68;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:69:7: ( 'saturate' )
|
|
// InternalRDL.g:69:9: 'saturate'
|
|
{
|
|
match("saturate");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__68"
|
|
|
|
// $ANTLR start "T__69"
|
|
public final void mT__69() throws RecognitionException {
|
|
try {
|
|
int _type = T__69;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:70:7: ( 'decrsaturate' )
|
|
// InternalRDL.g:70:9: 'decrsaturate'
|
|
{
|
|
match("decrsaturate");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__69"
|
|
|
|
// $ANTLR start "T__70"
|
|
public final void mT__70() throws RecognitionException {
|
|
try {
|
|
int _type = T__70;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:71:7: ( 'threshold' )
|
|
// InternalRDL.g:71:9: 'threshold'
|
|
{
|
|
match("threshold");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__70"
|
|
|
|
// $ANTLR start "T__71"
|
|
public final void mT__71() throws RecognitionException {
|
|
try {
|
|
int _type = T__71;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:72:7: ( 'decrthreshold' )
|
|
// InternalRDL.g:72:9: 'decrthreshold'
|
|
{
|
|
match("decrthreshold");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__71"
|
|
|
|
// $ANTLR start "T__72"
|
|
public final void mT__72() throws RecognitionException {
|
|
try {
|
|
int _type = T__72;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:73:7: ( 'dontcompare' )
|
|
// InternalRDL.g:73:9: 'dontcompare'
|
|
{
|
|
match("dontcompare");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__72"
|
|
|
|
// $ANTLR start "T__73"
|
|
public final void mT__73() throws RecognitionException {
|
|
try {
|
|
int _type = T__73;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:74:7: ( 'donttest' )
|
|
// InternalRDL.g:74:9: 'donttest'
|
|
{
|
|
match("donttest");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__73"
|
|
|
|
// $ANTLR start "T__74"
|
|
public final void mT__74() throws RecognitionException {
|
|
try {
|
|
int _type = T__74;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:75:7: ( 'internal' )
|
|
// InternalRDL.g:75:9: 'internal'
|
|
{
|
|
match("internal");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__74"
|
|
|
|
// $ANTLR start "T__75"
|
|
public final void mT__75() throws RecognitionException {
|
|
try {
|
|
int _type = T__75;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:76:7: ( 'alignment' )
|
|
// InternalRDL.g:76:9: 'alignment'
|
|
{
|
|
match("alignment");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__75"
|
|
|
|
// $ANTLR start "T__76"
|
|
public final void mT__76() throws RecognitionException {
|
|
try {
|
|
int _type = T__76;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:77:7: ( 'regwidth' )
|
|
// InternalRDL.g:77:9: 'regwidth'
|
|
{
|
|
match("regwidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__76"
|
|
|
|
// $ANTLR start "T__77"
|
|
public final void mT__77() throws RecognitionException {
|
|
try {
|
|
int _type = T__77;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:78:7: ( 'fieldwidth' )
|
|
// InternalRDL.g:78:9: 'fieldwidth'
|
|
{
|
|
match("fieldwidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__77"
|
|
|
|
// $ANTLR start "T__78"
|
|
public final void mT__78() throws RecognitionException {
|
|
try {
|
|
int _type = T__78;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:79:7: ( 'signalwidth' )
|
|
// InternalRDL.g:79:9: 'signalwidth'
|
|
{
|
|
match("signalwidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__78"
|
|
|
|
// $ANTLR start "T__79"
|
|
public final void mT__79() throws RecognitionException {
|
|
try {
|
|
int _type = T__79;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:80:7: ( 'accesswidth' )
|
|
// InternalRDL.g:80:9: 'accesswidth'
|
|
{
|
|
match("accesswidth");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__79"
|
|
|
|
// $ANTLR start "T__80"
|
|
public final void mT__80() throws RecognitionException {
|
|
try {
|
|
int _type = T__80;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:81:7: ( 'sw' )
|
|
// InternalRDL.g:81:9: 'sw'
|
|
{
|
|
match("sw");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__80"
|
|
|
|
// $ANTLR start "T__81"
|
|
public final void mT__81() throws RecognitionException {
|
|
try {
|
|
int _type = T__81;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:82:7: ( 'hw' )
|
|
// InternalRDL.g:82:9: 'hw'
|
|
{
|
|
match("hw");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__81"
|
|
|
|
// $ANTLR start "T__82"
|
|
public final void mT__82() throws RecognitionException {
|
|
try {
|
|
int _type = T__82;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:83:7: ( 'addressing' )
|
|
// InternalRDL.g:83:9: 'addressing'
|
|
{
|
|
match("addressing");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__82"
|
|
|
|
// $ANTLR start "T__83"
|
|
public final void mT__83() throws RecognitionException {
|
|
try {
|
|
int _type = T__83;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:84:7: ( 'precedence' )
|
|
// InternalRDL.g:84:9: 'precedence'
|
|
{
|
|
match("precedence");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__83"
|
|
|
|
// $ANTLR start "T__84"
|
|
public final void mT__84() throws RecognitionException {
|
|
try {
|
|
int _type = T__84;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:85:7: ( 'encode' )
|
|
// InternalRDL.g:85:9: 'encode'
|
|
{
|
|
match("encode");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__84"
|
|
|
|
// $ANTLR start "T__85"
|
|
public final void mT__85() throws RecognitionException {
|
|
try {
|
|
int _type = T__85;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:86:7: ( 'resetsignal' )
|
|
// InternalRDL.g:86:9: 'resetsignal'
|
|
{
|
|
match("resetsignal");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__85"
|
|
|
|
// $ANTLR start "T__86"
|
|
public final void mT__86() throws RecognitionException {
|
|
try {
|
|
int _type = T__86;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:87:7: ( 'clock' )
|
|
// InternalRDL.g:87:9: 'clock'
|
|
{
|
|
match("clock");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__86"
|
|
|
|
// $ANTLR start "T__87"
|
|
public final void mT__87() throws RecognitionException {
|
|
try {
|
|
int _type = T__87;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:88:7: ( 'mask' )
|
|
// InternalRDL.g:88:9: 'mask'
|
|
{
|
|
match("mask");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__87"
|
|
|
|
// $ANTLR start "T__88"
|
|
public final void mT__88() throws RecognitionException {
|
|
try {
|
|
int _type = T__88;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:89:7: ( 'enable' )
|
|
// InternalRDL.g:89:9: 'enable'
|
|
{
|
|
match("enable");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__88"
|
|
|
|
// $ANTLR start "T__89"
|
|
public final void mT__89() throws RecognitionException {
|
|
try {
|
|
int _type = T__89;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:90:7: ( 'hwenable' )
|
|
// InternalRDL.g:90:9: 'hwenable'
|
|
{
|
|
match("hwenable");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__89"
|
|
|
|
// $ANTLR start "T__90"
|
|
public final void mT__90() throws RecognitionException {
|
|
try {
|
|
int _type = T__90;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:91:7: ( 'hwmask' )
|
|
// InternalRDL.g:91:9: 'hwmask'
|
|
{
|
|
match("hwmask");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__90"
|
|
|
|
// $ANTLR start "T__91"
|
|
public final void mT__91() throws RecognitionException {
|
|
try {
|
|
int _type = T__91;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:92:7: ( 'haltmask' )
|
|
// InternalRDL.g:92:9: 'haltmask'
|
|
{
|
|
match("haltmask");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__91"
|
|
|
|
// $ANTLR start "T__92"
|
|
public final void mT__92() throws RecognitionException {
|
|
try {
|
|
int _type = T__92;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:93:7: ( 'haltenable' )
|
|
// InternalRDL.g:93:9: 'haltenable'
|
|
{
|
|
match("haltenable");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__92"
|
|
|
|
// $ANTLR start "T__93"
|
|
public final void mT__93() throws RecognitionException {
|
|
try {
|
|
int _type = T__93;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:94:7: ( 'halt' )
|
|
// InternalRDL.g:94:9: 'halt'
|
|
{
|
|
match("halt");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__93"
|
|
|
|
// $ANTLR start "T__94"
|
|
public final void mT__94() throws RecognitionException {
|
|
try {
|
|
int _type = T__94;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:95:7: ( 'next' )
|
|
// InternalRDL.g:95:9: 'next'
|
|
{
|
|
match("next");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__94"
|
|
|
|
// $ANTLR start "T__95"
|
|
public final void mT__95() throws RecognitionException {
|
|
try {
|
|
int _type = T__95;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:96:7: ( 'UNDEFINED' )
|
|
// InternalRDL.g:96:9: 'UNDEFINED'
|
|
{
|
|
match("UNDEFINED");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__95"
|
|
|
|
// $ANTLR start "T__96"
|
|
public final void mT__96() throws RecognitionException {
|
|
try {
|
|
int _type = T__96;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:97:7: ( 'true' )
|
|
// InternalRDL.g:97:9: 'true'
|
|
{
|
|
match("true");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__96"
|
|
|
|
// $ANTLR start "T__97"
|
|
public final void mT__97() throws RecognitionException {
|
|
try {
|
|
int _type = T__97;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:98:7: ( 'false' )
|
|
// InternalRDL.g:98:9: 'false'
|
|
{
|
|
match("false");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__97"
|
|
|
|
// $ANTLR start "T__98"
|
|
public final void mT__98() throws RecognitionException {
|
|
try {
|
|
int _type = T__98;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:99:7: ( 'rw' )
|
|
// InternalRDL.g:99:9: 'rw'
|
|
{
|
|
match("rw");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__98"
|
|
|
|
// $ANTLR start "T__99"
|
|
public final void mT__99() throws RecognitionException {
|
|
try {
|
|
int _type = T__99;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:100:7: ( 'wr' )
|
|
// InternalRDL.g:100:9: 'wr'
|
|
{
|
|
match("wr");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__99"
|
|
|
|
// $ANTLR start "T__100"
|
|
public final void mT__100() throws RecognitionException {
|
|
try {
|
|
int _type = T__100;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:101:8: ( 'r' )
|
|
// InternalRDL.g:101:10: 'r'
|
|
{
|
|
match('r');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__100"
|
|
|
|
// $ANTLR start "T__101"
|
|
public final void mT__101() throws RecognitionException {
|
|
try {
|
|
int _type = T__101;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:102:8: ( 'w' )
|
|
// InternalRDL.g:102:10: 'w'
|
|
{
|
|
match('w');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__101"
|
|
|
|
// $ANTLR start "T__102"
|
|
public final void mT__102() throws RecognitionException {
|
|
try {
|
|
int _type = T__102;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:103:8: ( 'na' )
|
|
// InternalRDL.g:103:10: 'na'
|
|
{
|
|
match("na");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__102"
|
|
|
|
// $ANTLR start "T__103"
|
|
public final void mT__103() throws RecognitionException {
|
|
try {
|
|
int _type = T__103;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:104:8: ( 'compact' )
|
|
// InternalRDL.g:104:10: 'compact'
|
|
{
|
|
match("compact");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__103"
|
|
|
|
// $ANTLR start "T__104"
|
|
public final void mT__104() throws RecognitionException {
|
|
try {
|
|
int _type = T__104;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:105:8: ( 'regalign' )
|
|
// InternalRDL.g:105:10: 'regalign'
|
|
{
|
|
match("regalign");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__104"
|
|
|
|
// $ANTLR start "T__105"
|
|
public final void mT__105() throws RecognitionException {
|
|
try {
|
|
int _type = T__105;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:106:8: ( 'fullalign' )
|
|
// InternalRDL.g:106:10: 'fullalign'
|
|
{
|
|
match("fullalign");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__105"
|
|
|
|
// $ANTLR start "T__106"
|
|
public final void mT__106() throws RecognitionException {
|
|
try {
|
|
int _type = T__106;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:107:8: ( 'posedge' )
|
|
// InternalRDL.g:107:10: 'posedge'
|
|
{
|
|
match("posedge");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__106"
|
|
|
|
// $ANTLR start "T__107"
|
|
public final void mT__107() throws RecognitionException {
|
|
try {
|
|
int _type = T__107;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:108:8: ( 'negedge' )
|
|
// InternalRDL.g:108:10: 'negedge'
|
|
{
|
|
match("negedge");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__107"
|
|
|
|
// $ANTLR start "T__108"
|
|
public final void mT__108() throws RecognitionException {
|
|
try {
|
|
int _type = T__108;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:109:8: ( 'bothedge' )
|
|
// InternalRDL.g:109:10: 'bothedge'
|
|
{
|
|
match("bothedge");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__108"
|
|
|
|
// $ANTLR start "T__109"
|
|
public final void mT__109() throws RecognitionException {
|
|
try {
|
|
int _type = T__109;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:110:8: ( 'level' )
|
|
// InternalRDL.g:110:10: 'level'
|
|
{
|
|
match("level");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__109"
|
|
|
|
// $ANTLR start "T__110"
|
|
public final void mT__110() throws RecognitionException {
|
|
try {
|
|
int _type = T__110;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:111:8: ( 'nonsticky' )
|
|
// InternalRDL.g:111:10: 'nonsticky'
|
|
{
|
|
match("nonsticky");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__110"
|
|
|
|
// $ANTLR start "T__111"
|
|
public final void mT__111() throws RecognitionException {
|
|
try {
|
|
int _type = T__111;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:112:8: ( '`include' )
|
|
// InternalRDL.g:112:10: '`include'
|
|
{
|
|
match("`include");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__111"
|
|
|
|
// $ANTLR start "T__112"
|
|
public final void mT__112() throws RecognitionException {
|
|
try {
|
|
int _type = T__112;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:113:8: ( 'property' )
|
|
// InternalRDL.g:113:10: 'property'
|
|
{
|
|
match("property");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__112"
|
|
|
|
// $ANTLR start "T__113"
|
|
public final void mT__113() throws RecognitionException {
|
|
try {
|
|
int _type = T__113;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:114:8: ( '{' )
|
|
// InternalRDL.g:114:10: '{'
|
|
{
|
|
match('{');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__113"
|
|
|
|
// $ANTLR start "T__114"
|
|
public final void mT__114() throws RecognitionException {
|
|
try {
|
|
int _type = T__114;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:115:8: ( '}' )
|
|
// InternalRDL.g:115:10: '}'
|
|
{
|
|
match('}');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__114"
|
|
|
|
// $ANTLR start "T__115"
|
|
public final void mT__115() throws RecognitionException {
|
|
try {
|
|
int _type = T__115;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:116:8: ( ';' )
|
|
// InternalRDL.g:116:10: ';'
|
|
{
|
|
match(';');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__115"
|
|
|
|
// $ANTLR start "T__116"
|
|
public final void mT__116() throws RecognitionException {
|
|
try {
|
|
int _type = T__116;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:117:8: ( 'type' )
|
|
// InternalRDL.g:117:10: 'type'
|
|
{
|
|
match("type");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__116"
|
|
|
|
// $ANTLR start "T__117"
|
|
public final void mT__117() throws RecognitionException {
|
|
try {
|
|
int _type = T__117;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:118:8: ( '=' )
|
|
// InternalRDL.g:118:10: '='
|
|
{
|
|
match('=');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__117"
|
|
|
|
// $ANTLR start "T__118"
|
|
public final void mT__118() throws RecognitionException {
|
|
try {
|
|
int _type = T__118;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:119:8: ( 'default' )
|
|
// InternalRDL.g:119:10: 'default'
|
|
{
|
|
match("default");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__118"
|
|
|
|
// $ANTLR start "T__119"
|
|
public final void mT__119() throws RecognitionException {
|
|
try {
|
|
int _type = T__119;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:120:8: ( 'component' )
|
|
// InternalRDL.g:120:10: 'component'
|
|
{
|
|
match("component");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__119"
|
|
|
|
// $ANTLR start "T__120"
|
|
public final void mT__120() throws RecognitionException {
|
|
try {
|
|
int _type = T__120;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:121:8: ( '|' )
|
|
// InternalRDL.g:121:10: '|'
|
|
{
|
|
match('|');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__120"
|
|
|
|
// $ANTLR start "T__121"
|
|
public final void mT__121() throws RecognitionException {
|
|
try {
|
|
int _type = T__121;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:122:8: ( 'alias' )
|
|
// InternalRDL.g:122:10: 'alias'
|
|
{
|
|
match("alias");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__121"
|
|
|
|
// $ANTLR start "T__122"
|
|
public final void mT__122() throws RecognitionException {
|
|
try {
|
|
int _type = T__122;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:123:8: ( ',' )
|
|
// InternalRDL.g:123:10: ','
|
|
{
|
|
match(',');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__122"
|
|
|
|
// $ANTLR start "T__123"
|
|
public final void mT__123() throws RecognitionException {
|
|
try {
|
|
int _type = T__123;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:124:8: ( '@' )
|
|
// InternalRDL.g:124:10: '@'
|
|
{
|
|
match('@');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__123"
|
|
|
|
// $ANTLR start "T__124"
|
|
public final void mT__124() throws RecognitionException {
|
|
try {
|
|
int _type = T__124;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:125:8: ( '+=' )
|
|
// InternalRDL.g:125:10: '+='
|
|
{
|
|
match("+=");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__124"
|
|
|
|
// $ANTLR start "T__125"
|
|
public final void mT__125() throws RecognitionException {
|
|
try {
|
|
int _type = T__125;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:126:8: ( '%=' )
|
|
// InternalRDL.g:126:10: '%='
|
|
{
|
|
match("%=");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__125"
|
|
|
|
// $ANTLR start "T__126"
|
|
public final void mT__126() throws RecognitionException {
|
|
try {
|
|
int _type = T__126;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:127:8: ( '[' )
|
|
// InternalRDL.g:127:10: '['
|
|
{
|
|
match('[');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__126"
|
|
|
|
// $ANTLR start "T__127"
|
|
public final void mT__127() throws RecognitionException {
|
|
try {
|
|
int _type = T__127;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:128:8: ( ']' )
|
|
// InternalRDL.g:128:10: ']'
|
|
{
|
|
match(']');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__127"
|
|
|
|
// $ANTLR start "T__128"
|
|
public final void mT__128() throws RecognitionException {
|
|
try {
|
|
int _type = T__128;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:129:8: ( ':' )
|
|
// InternalRDL.g:129:10: ':'
|
|
{
|
|
match(':');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__128"
|
|
|
|
// $ANTLR start "T__129"
|
|
public final void mT__129() throws RecognitionException {
|
|
try {
|
|
int _type = T__129;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:130:8: ( '->' )
|
|
// InternalRDL.g:130:10: '->'
|
|
{
|
|
match("->");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__129"
|
|
|
|
// $ANTLR start "T__130"
|
|
public final void mT__130() throws RecognitionException {
|
|
try {
|
|
int _type = T__130;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:131:8: ( '.' )
|
|
// InternalRDL.g:131:10: '.'
|
|
{
|
|
match('.');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__130"
|
|
|
|
// $ANTLR start "T__131"
|
|
public final void mT__131() throws RecognitionException {
|
|
try {
|
|
int _type = T__131;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:132:8: ( 'enum' )
|
|
// InternalRDL.g:132:10: 'enum'
|
|
{
|
|
match("enum");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__131"
|
|
|
|
// $ANTLR start "T__132"
|
|
public final void mT__132() throws RecognitionException {
|
|
try {
|
|
int _type = T__132;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:133:8: ( 'external' )
|
|
// InternalRDL.g:133:10: 'external'
|
|
{
|
|
match("external");
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "T__132"
|
|
|
|
// $ANTLR start "RULE_ID"
|
|
public final void mRULE_ID() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_ID;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7642:9: ( ( '\\\\' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
|
|
// InternalRDL.g:7642:11: ( '\\\\' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
|
|
{
|
|
// InternalRDL.g:7642:11: ( '\\\\' )?
|
|
int alt1=2;
|
|
int LA1_0 = input.LA(1);
|
|
|
|
if ( (LA1_0=='\\') ) {
|
|
alt1=1;
|
|
}
|
|
switch (alt1) {
|
|
case 1 :
|
|
// InternalRDL.g:7642:11: '\\\\'
|
|
{
|
|
match('\\');
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
// InternalRDL.g:7642:41: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
|
|
loop2:
|
|
do {
|
|
int alt2=2;
|
|
int LA2_0 = input.LA(1);
|
|
|
|
if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='Z')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='z')) ) {
|
|
alt2=1;
|
|
}
|
|
|
|
|
|
switch (alt2) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop2;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_ID"
|
|
|
|
// $ANTLR start "RULE_WS"
|
|
public final void mRULE_WS() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_WS;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7644:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
|
|
// InternalRDL.g:7644:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
|
|
{
|
|
// InternalRDL.g:7644:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
|
|
int cnt3=0;
|
|
loop3:
|
|
do {
|
|
int alt3=2;
|
|
int LA3_0 = input.LA(1);
|
|
|
|
if ( ((LA3_0>='\t' && LA3_0<='\n')||LA3_0=='\r'||LA3_0==' ') ) {
|
|
alt3=1;
|
|
}
|
|
|
|
|
|
switch (alt3) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||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);
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_WS"
|
|
|
|
// $ANTLR start "RULE_ML_COMMENT"
|
|
public final void mRULE_ML_COMMENT() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_ML_COMMENT;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7646:17: ( ( '/*' ( options {greedy=false; } : . )* '*/' | '<%' ( options {greedy=false; } : . )* '%>' | '(' ( options {greedy=false; } : . )* ')' ) )
|
|
// InternalRDL.g:7646:19: ( '/*' ( options {greedy=false; } : . )* '*/' | '<%' ( options {greedy=false; } : . )* '%>' | '(' ( options {greedy=false; } : . )* ')' )
|
|
{
|
|
// InternalRDL.g:7646:19: ( '/*' ( options {greedy=false; } : . )* '*/' | '<%' ( options {greedy=false; } : . )* '%>' | '(' ( options {greedy=false; } : . )* ')' )
|
|
int alt7=3;
|
|
switch ( input.LA(1) ) {
|
|
case '/':
|
|
{
|
|
alt7=1;
|
|
}
|
|
break;
|
|
case '<':
|
|
{
|
|
alt7=2;
|
|
}
|
|
break;
|
|
case '(':
|
|
{
|
|
alt7=3;
|
|
}
|
|
break;
|
|
default:
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 7, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt7) {
|
|
case 1 :
|
|
// InternalRDL.g:7646:20: '/*' ( options {greedy=false; } : . )* '*/'
|
|
{
|
|
match("/*");
|
|
|
|
// InternalRDL.g:7646:25: ( options {greedy=false; } : . )*
|
|
loop4:
|
|
do {
|
|
int alt4=2;
|
|
int LA4_0 = input.LA(1);
|
|
|
|
if ( (LA4_0=='*') ) {
|
|
int LA4_1 = input.LA(2);
|
|
|
|
if ( (LA4_1=='/') ) {
|
|
alt4=2;
|
|
}
|
|
else if ( ((LA4_1>='\u0000' && LA4_1<='.')||(LA4_1>='0' && LA4_1<='\uFFFF')) ) {
|
|
alt4=1;
|
|
}
|
|
|
|
|
|
}
|
|
else if ( ((LA4_0>='\u0000' && LA4_0<=')')||(LA4_0>='+' && LA4_0<='\uFFFF')) ) {
|
|
alt4=1;
|
|
}
|
|
|
|
|
|
switch (alt4) {
|
|
case 1 :
|
|
// InternalRDL.g:7646:53: .
|
|
{
|
|
matchAny();
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop4;
|
|
}
|
|
} while (true);
|
|
|
|
match("*/");
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:7646:62: '<%' ( options {greedy=false; } : . )* '%>'
|
|
{
|
|
match("<%");
|
|
|
|
// InternalRDL.g:7646:67: ( options {greedy=false; } : . )*
|
|
loop5:
|
|
do {
|
|
int alt5=2;
|
|
int LA5_0 = input.LA(1);
|
|
|
|
if ( (LA5_0=='%') ) {
|
|
int LA5_1 = input.LA(2);
|
|
|
|
if ( (LA5_1=='>') ) {
|
|
alt5=2;
|
|
}
|
|
else if ( ((LA5_1>='\u0000' && LA5_1<='=')||(LA5_1>='?' && LA5_1<='\uFFFF')) ) {
|
|
alt5=1;
|
|
}
|
|
|
|
|
|
}
|
|
else if ( ((LA5_0>='\u0000' && LA5_0<='$')||(LA5_0>='&' && LA5_0<='\uFFFF')) ) {
|
|
alt5=1;
|
|
}
|
|
|
|
|
|
switch (alt5) {
|
|
case 1 :
|
|
// InternalRDL.g:7646:95: .
|
|
{
|
|
matchAny();
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop5;
|
|
}
|
|
} while (true);
|
|
|
|
match("%>");
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:7646:104: '(' ( options {greedy=false; } : . )* ')'
|
|
{
|
|
match('(');
|
|
// InternalRDL.g:7646:108: ( options {greedy=false; } : . )*
|
|
loop6:
|
|
do {
|
|
int alt6=2;
|
|
int LA6_0 = input.LA(1);
|
|
|
|
if ( (LA6_0==')') ) {
|
|
alt6=2;
|
|
}
|
|
else if ( ((LA6_0>='\u0000' && LA6_0<='(')||(LA6_0>='*' && LA6_0<='\uFFFF')) ) {
|
|
alt6=1;
|
|
}
|
|
|
|
|
|
switch (alt6) {
|
|
case 1 :
|
|
// InternalRDL.g:7646:136: .
|
|
{
|
|
matchAny();
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop6;
|
|
}
|
|
} while (true);
|
|
|
|
match(')');
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_ML_COMMENT"
|
|
|
|
// $ANTLR start "RULE_SL_COMMENT"
|
|
public final void mRULE_SL_COMMENT() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_SL_COMMENT;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7648:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
|
|
// InternalRDL.g:7648:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
|
|
{
|
|
match("//");
|
|
|
|
// InternalRDL.g:7648:24: (~ ( ( '\\n' | '\\r' ) ) )*
|
|
loop8:
|
|
do {
|
|
int alt8=2;
|
|
int LA8_0 = input.LA(1);
|
|
|
|
if ( ((LA8_0>='\u0000' && LA8_0<='\t')||(LA8_0>='\u000B' && LA8_0<='\f')||(LA8_0>='\u000E' && LA8_0<='\uFFFF')) ) {
|
|
alt8=1;
|
|
}
|
|
|
|
|
|
switch (alt8) {
|
|
case 1 :
|
|
// InternalRDL.g:7648:24: ~ ( ( '\\n' | '\\r' ) )
|
|
{
|
|
if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop8;
|
|
}
|
|
} while (true);
|
|
|
|
// InternalRDL.g:7648:40: ( ( '\\r' )? '\\n' )?
|
|
int alt10=2;
|
|
int LA10_0 = input.LA(1);
|
|
|
|
if ( (LA10_0=='\n'||LA10_0=='\r') ) {
|
|
alt10=1;
|
|
}
|
|
switch (alt10) {
|
|
case 1 :
|
|
// InternalRDL.g:7648:41: ( '\\r' )? '\\n'
|
|
{
|
|
// InternalRDL.g:7648:41: ( '\\r' )?
|
|
int alt9=2;
|
|
int LA9_0 = input.LA(1);
|
|
|
|
if ( (LA9_0=='\r') ) {
|
|
alt9=1;
|
|
}
|
|
switch (alt9) {
|
|
case 1 :
|
|
// InternalRDL.g:7648:41: '\\r'
|
|
{
|
|
match('\r');
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
match('\n');
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_SL_COMMENT"
|
|
|
|
// $ANTLR start "RULE_NUM"
|
|
public final void mRULE_NUM() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_NUM;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7650:10: ( ( ( '0' .. '9' )+ '\\'b' ( '0' | '1' | '_' )+ | ( '0' .. '9' )+ '\\'o' ( '0' .. '7' | '_' )+ | ( '0' .. '9' )+ '\\'h' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ | ( '0' .. '9' )+ '\\'d' ( '0' .. '9' | '_' )+ | '0x' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | ( '0' .. '9' )+ ) )
|
|
// InternalRDL.g:7650:12: ( ( '0' .. '9' )+ '\\'b' ( '0' | '1' | '_' )+ | ( '0' .. '9' )+ '\\'o' ( '0' .. '7' | '_' )+ | ( '0' .. '9' )+ '\\'h' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ | ( '0' .. '9' )+ '\\'d' ( '0' .. '9' | '_' )+ | '0x' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | ( '0' .. '9' )+ )
|
|
{
|
|
// InternalRDL.g:7650:12: ( ( '0' .. '9' )+ '\\'b' ( '0' | '1' | '_' )+ | ( '0' .. '9' )+ '\\'o' ( '0' .. '7' | '_' )+ | ( '0' .. '9' )+ '\\'h' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ | ( '0' .. '9' )+ '\\'d' ( '0' .. '9' | '_' )+ | '0x' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | ( '0' .. '9' )+ )
|
|
int alt21=6;
|
|
alt21 = dfa21.predict(input);
|
|
switch (alt21) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:13: ( '0' .. '9' )+ '\\'b' ( '0' | '1' | '_' )+
|
|
{
|
|
// InternalRDL.g:7650:13: ( '0' .. '9' )+
|
|
int cnt11=0;
|
|
loop11:
|
|
do {
|
|
int alt11=2;
|
|
int LA11_0 = input.LA(1);
|
|
|
|
if ( ((LA11_0>='0' && LA11_0<='9')) ) {
|
|
alt11=1;
|
|
}
|
|
|
|
|
|
switch (alt11) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:14: '0' .. '9'
|
|
{
|
|
matchRange('0','9');
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt11 >= 1 ) break loop11;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(11, input);
|
|
throw eee;
|
|
}
|
|
cnt11++;
|
|
} while (true);
|
|
|
|
match("'b");
|
|
|
|
// InternalRDL.g:7650:31: ( '0' | '1' | '_' )+
|
|
int cnt12=0;
|
|
loop12:
|
|
do {
|
|
int alt12=2;
|
|
int LA12_0 = input.LA(1);
|
|
|
|
if ( ((LA12_0>='0' && LA12_0<='1')||LA12_0=='_') ) {
|
|
alt12=1;
|
|
}
|
|
|
|
|
|
switch (alt12) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='1')||input.LA(1)=='_' ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt12 >= 1 ) break loop12;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(12, input);
|
|
throw eee;
|
|
}
|
|
cnt12++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:7650:46: ( '0' .. '9' )+ '\\'o' ( '0' .. '7' | '_' )+
|
|
{
|
|
// InternalRDL.g:7650:46: ( '0' .. '9' )+
|
|
int cnt13=0;
|
|
loop13:
|
|
do {
|
|
int alt13=2;
|
|
int LA13_0 = input.LA(1);
|
|
|
|
if ( ((LA13_0>='0' && LA13_0<='9')) ) {
|
|
alt13=1;
|
|
}
|
|
|
|
|
|
switch (alt13) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:47: '0' .. '9'
|
|
{
|
|
matchRange('0','9');
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt13 >= 1 ) break loop13;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(13, input);
|
|
throw eee;
|
|
}
|
|
cnt13++;
|
|
} while (true);
|
|
|
|
match("'o");
|
|
|
|
// InternalRDL.g:7650:64: ( '0' .. '7' | '_' )+
|
|
int cnt14=0;
|
|
loop14:
|
|
do {
|
|
int alt14=2;
|
|
int LA14_0 = input.LA(1);
|
|
|
|
if ( ((LA14_0>='0' && LA14_0<='7')||LA14_0=='_') ) {
|
|
alt14=1;
|
|
}
|
|
|
|
|
|
switch (alt14) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='7')||input.LA(1)=='_' ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt14 >= 1 ) break loop14;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(14, input);
|
|
throw eee;
|
|
}
|
|
cnt14++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:7650:80: ( '0' .. '9' )+ '\\'h' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
|
|
{
|
|
// InternalRDL.g:7650:80: ( '0' .. '9' )+
|
|
int cnt15=0;
|
|
loop15:
|
|
do {
|
|
int alt15=2;
|
|
int LA15_0 = input.LA(1);
|
|
|
|
if ( ((LA15_0>='0' && LA15_0<='9')) ) {
|
|
alt15=1;
|
|
}
|
|
|
|
|
|
switch (alt15) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:81: '0' .. '9'
|
|
{
|
|
matchRange('0','9');
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt15 >= 1 ) break loop15;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(15, input);
|
|
throw eee;
|
|
}
|
|
cnt15++;
|
|
} while (true);
|
|
|
|
match("'h");
|
|
|
|
// InternalRDL.g:7650:98: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
|
|
int cnt16=0;
|
|
loop16:
|
|
do {
|
|
int alt16=2;
|
|
int LA16_0 = input.LA(1);
|
|
|
|
if ( ((LA16_0>='0' && LA16_0<='9')||(LA16_0>='A' && LA16_0<='F')||LA16_0=='_'||(LA16_0>='a' && LA16_0<='f')) ) {
|
|
alt16=1;
|
|
}
|
|
|
|
|
|
switch (alt16) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt16 >= 1 ) break loop16;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(16, input);
|
|
throw eee;
|
|
}
|
|
cnt16++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:7650:132: ( '0' .. '9' )+ '\\'d' ( '0' .. '9' | '_' )+
|
|
{
|
|
// InternalRDL.g:7650:132: ( '0' .. '9' )+
|
|
int cnt17=0;
|
|
loop17:
|
|
do {
|
|
int alt17=2;
|
|
int LA17_0 = input.LA(1);
|
|
|
|
if ( ((LA17_0>='0' && LA17_0<='9')) ) {
|
|
alt17=1;
|
|
}
|
|
|
|
|
|
switch (alt17) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:133: '0' .. '9'
|
|
{
|
|
matchRange('0','9');
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt17 >= 1 ) break loop17;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(17, input);
|
|
throw eee;
|
|
}
|
|
cnt17++;
|
|
} while (true);
|
|
|
|
match("'d");
|
|
|
|
// InternalRDL.g:7650:150: ( '0' .. '9' | '_' )+
|
|
int cnt18=0;
|
|
loop18:
|
|
do {
|
|
int alt18=2;
|
|
int LA18_0 = input.LA(1);
|
|
|
|
if ( ((LA18_0>='0' && LA18_0<='9')||LA18_0=='_') ) {
|
|
alt18=1;
|
|
}
|
|
|
|
|
|
switch (alt18) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt18 >= 1 ) break loop18;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(18, input);
|
|
throw eee;
|
|
}
|
|
cnt18++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:7650:166: '0x' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
|
|
{
|
|
match("0x");
|
|
|
|
// InternalRDL.g:7650:171: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+
|
|
int cnt19=0;
|
|
loop19:
|
|
do {
|
|
int alt19=2;
|
|
int LA19_0 = input.LA(1);
|
|
|
|
if ( ((LA19_0>='0' && LA19_0<='9')||(LA19_0>='A' && LA19_0<='F')||(LA19_0>='a' && LA19_0<='f')) ) {
|
|
alt19=1;
|
|
}
|
|
|
|
|
|
switch (alt19) {
|
|
case 1 :
|
|
// InternalRDL.g:
|
|
{
|
|
if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt19 >= 1 ) break loop19;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(19, input);
|
|
throw eee;
|
|
}
|
|
cnt19++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:7650:201: ( '0' .. '9' )+
|
|
{
|
|
// InternalRDL.g:7650:201: ( '0' .. '9' )+
|
|
int cnt20=0;
|
|
loop20:
|
|
do {
|
|
int alt20=2;
|
|
int LA20_0 = input.LA(1);
|
|
|
|
if ( ((LA20_0>='0' && LA20_0<='9')) ) {
|
|
alt20=1;
|
|
}
|
|
|
|
|
|
switch (alt20) {
|
|
case 1 :
|
|
// InternalRDL.g:7650:202: '0' .. '9'
|
|
{
|
|
matchRange('0','9');
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt20 >= 1 ) break loop20;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(20, input);
|
|
throw eee;
|
|
}
|
|
cnt20++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_NUM"
|
|
|
|
// $ANTLR start "RULE_STR"
|
|
public final void mRULE_STR() throws RecognitionException {
|
|
try {
|
|
int _type = RULE_STR;
|
|
int _channel = DEFAULT_TOKEN_CHANNEL;
|
|
// InternalRDL.g:7652:10: ( '\"' ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* '\"' )
|
|
// InternalRDL.g:7652:12: '\"' ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
|
|
{
|
|
match('\"');
|
|
// InternalRDL.g:7652:16: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' ) | ~ ( ( '\\\\' | '\"' ) ) )*
|
|
loop22:
|
|
do {
|
|
int alt22=3;
|
|
int LA22_0 = input.LA(1);
|
|
|
|
if ( (LA22_0=='\\') ) {
|
|
alt22=1;
|
|
}
|
|
else if ( ((LA22_0>='\u0000' && LA22_0<='!')||(LA22_0>='#' && LA22_0<='[')||(LA22_0>=']' && LA22_0<='\uFFFF')) ) {
|
|
alt22=2;
|
|
}
|
|
|
|
|
|
switch (alt22) {
|
|
case 1 :
|
|
// InternalRDL.g:7652:17: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | 'u' | '\"' | '\\'' | '\\\\' )
|
|
{
|
|
match('\\');
|
|
if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||(input.LA(1)>='t' && input.LA(1)<='u') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:7652:62: ~ ( ( '\\\\' | '\"' ) )
|
|
{
|
|
if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
|
|
input.consume();
|
|
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
recover(mse);
|
|
throw mse;}
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop22;
|
|
}
|
|
} while (true);
|
|
|
|
match('\"');
|
|
|
|
}
|
|
|
|
state.type = _type;
|
|
state.channel = _channel;
|
|
}
|
|
finally {
|
|
}
|
|
}
|
|
// $ANTLR end "RULE_STR"
|
|
|
|
public void mTokens() throws RecognitionException {
|
|
// InternalRDL.g:1:8: ( T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | T__123 | T__124 | T__125 | T__126 | T__127 | T__128 | T__129 | T__130 | T__131 | T__132 | RULE_ID | RULE_WS | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_NUM | RULE_STR )
|
|
int alt23=129;
|
|
alt23 = dfa23.predict(input);
|
|
switch (alt23) {
|
|
case 1 :
|
|
// InternalRDL.g:1:10: T__10
|
|
{
|
|
mT__10();
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// InternalRDL.g:1:16: T__11
|
|
{
|
|
mT__11();
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// InternalRDL.g:1:22: T__12
|
|
{
|
|
mT__12();
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// InternalRDL.g:1:28: T__13
|
|
{
|
|
mT__13();
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// InternalRDL.g:1:34: T__14
|
|
{
|
|
mT__14();
|
|
|
|
}
|
|
break;
|
|
case 6 :
|
|
// InternalRDL.g:1:40: T__15
|
|
{
|
|
mT__15();
|
|
|
|
}
|
|
break;
|
|
case 7 :
|
|
// InternalRDL.g:1:46: T__16
|
|
{
|
|
mT__16();
|
|
|
|
}
|
|
break;
|
|
case 8 :
|
|
// InternalRDL.g:1:52: T__17
|
|
{
|
|
mT__17();
|
|
|
|
}
|
|
break;
|
|
case 9 :
|
|
// InternalRDL.g:1:58: T__18
|
|
{
|
|
mT__18();
|
|
|
|
}
|
|
break;
|
|
case 10 :
|
|
// InternalRDL.g:1:64: T__19
|
|
{
|
|
mT__19();
|
|
|
|
}
|
|
break;
|
|
case 11 :
|
|
// InternalRDL.g:1:70: T__20
|
|
{
|
|
mT__20();
|
|
|
|
}
|
|
break;
|
|
case 12 :
|
|
// InternalRDL.g:1:76: T__21
|
|
{
|
|
mT__21();
|
|
|
|
}
|
|
break;
|
|
case 13 :
|
|
// InternalRDL.g:1:82: T__22
|
|
{
|
|
mT__22();
|
|
|
|
}
|
|
break;
|
|
case 14 :
|
|
// InternalRDL.g:1:88: T__23
|
|
{
|
|
mT__23();
|
|
|
|
}
|
|
break;
|
|
case 15 :
|
|
// InternalRDL.g:1:94: T__24
|
|
{
|
|
mT__24();
|
|
|
|
}
|
|
break;
|
|
case 16 :
|
|
// InternalRDL.g:1:100: T__25
|
|
{
|
|
mT__25();
|
|
|
|
}
|
|
break;
|
|
case 17 :
|
|
// InternalRDL.g:1:106: T__26
|
|
{
|
|
mT__26();
|
|
|
|
}
|
|
break;
|
|
case 18 :
|
|
// InternalRDL.g:1:112: T__27
|
|
{
|
|
mT__27();
|
|
|
|
}
|
|
break;
|
|
case 19 :
|
|
// InternalRDL.g:1:118: T__28
|
|
{
|
|
mT__28();
|
|
|
|
}
|
|
break;
|
|
case 20 :
|
|
// InternalRDL.g:1:124: T__29
|
|
{
|
|
mT__29();
|
|
|
|
}
|
|
break;
|
|
case 21 :
|
|
// InternalRDL.g:1:130: T__30
|
|
{
|
|
mT__30();
|
|
|
|
}
|
|
break;
|
|
case 22 :
|
|
// InternalRDL.g:1:136: T__31
|
|
{
|
|
mT__31();
|
|
|
|
}
|
|
break;
|
|
case 23 :
|
|
// InternalRDL.g:1:142: T__32
|
|
{
|
|
mT__32();
|
|
|
|
}
|
|
break;
|
|
case 24 :
|
|
// InternalRDL.g:1:148: T__33
|
|
{
|
|
mT__33();
|
|
|
|
}
|
|
break;
|
|
case 25 :
|
|
// InternalRDL.g:1:154: T__34
|
|
{
|
|
mT__34();
|
|
|
|
}
|
|
break;
|
|
case 26 :
|
|
// InternalRDL.g:1:160: T__35
|
|
{
|
|
mT__35();
|
|
|
|
}
|
|
break;
|
|
case 27 :
|
|
// InternalRDL.g:1:166: T__36
|
|
{
|
|
mT__36();
|
|
|
|
}
|
|
break;
|
|
case 28 :
|
|
// InternalRDL.g:1:172: T__37
|
|
{
|
|
mT__37();
|
|
|
|
}
|
|
break;
|
|
case 29 :
|
|
// InternalRDL.g:1:178: T__38
|
|
{
|
|
mT__38();
|
|
|
|
}
|
|
break;
|
|
case 30 :
|
|
// InternalRDL.g:1:184: T__39
|
|
{
|
|
mT__39();
|
|
|
|
}
|
|
break;
|
|
case 31 :
|
|
// InternalRDL.g:1:190: T__40
|
|
{
|
|
mT__40();
|
|
|
|
}
|
|
break;
|
|
case 32 :
|
|
// InternalRDL.g:1:196: T__41
|
|
{
|
|
mT__41();
|
|
|
|
}
|
|
break;
|
|
case 33 :
|
|
// InternalRDL.g:1:202: T__42
|
|
{
|
|
mT__42();
|
|
|
|
}
|
|
break;
|
|
case 34 :
|
|
// InternalRDL.g:1:208: T__43
|
|
{
|
|
mT__43();
|
|
|
|
}
|
|
break;
|
|
case 35 :
|
|
// InternalRDL.g:1:214: T__44
|
|
{
|
|
mT__44();
|
|
|
|
}
|
|
break;
|
|
case 36 :
|
|
// InternalRDL.g:1:220: T__45
|
|
{
|
|
mT__45();
|
|
|
|
}
|
|
break;
|
|
case 37 :
|
|
// InternalRDL.g:1:226: T__46
|
|
{
|
|
mT__46();
|
|
|
|
}
|
|
break;
|
|
case 38 :
|
|
// InternalRDL.g:1:232: T__47
|
|
{
|
|
mT__47();
|
|
|
|
}
|
|
break;
|
|
case 39 :
|
|
// InternalRDL.g:1:238: T__48
|
|
{
|
|
mT__48();
|
|
|
|
}
|
|
break;
|
|
case 40 :
|
|
// InternalRDL.g:1:244: T__49
|
|
{
|
|
mT__49();
|
|
|
|
}
|
|
break;
|
|
case 41 :
|
|
// InternalRDL.g:1:250: T__50
|
|
{
|
|
mT__50();
|
|
|
|
}
|
|
break;
|
|
case 42 :
|
|
// InternalRDL.g:1:256: T__51
|
|
{
|
|
mT__51();
|
|
|
|
}
|
|
break;
|
|
case 43 :
|
|
// InternalRDL.g:1:262: T__52
|
|
{
|
|
mT__52();
|
|
|
|
}
|
|
break;
|
|
case 44 :
|
|
// InternalRDL.g:1:268: T__53
|
|
{
|
|
mT__53();
|
|
|
|
}
|
|
break;
|
|
case 45 :
|
|
// InternalRDL.g:1:274: T__54
|
|
{
|
|
mT__54();
|
|
|
|
}
|
|
break;
|
|
case 46 :
|
|
// InternalRDL.g:1:280: T__55
|
|
{
|
|
mT__55();
|
|
|
|
}
|
|
break;
|
|
case 47 :
|
|
// InternalRDL.g:1:286: T__56
|
|
{
|
|
mT__56();
|
|
|
|
}
|
|
break;
|
|
case 48 :
|
|
// InternalRDL.g:1:292: T__57
|
|
{
|
|
mT__57();
|
|
|
|
}
|
|
break;
|
|
case 49 :
|
|
// InternalRDL.g:1:298: T__58
|
|
{
|
|
mT__58();
|
|
|
|
}
|
|
break;
|
|
case 50 :
|
|
// InternalRDL.g:1:304: T__59
|
|
{
|
|
mT__59();
|
|
|
|
}
|
|
break;
|
|
case 51 :
|
|
// InternalRDL.g:1:310: T__60
|
|
{
|
|
mT__60();
|
|
|
|
}
|
|
break;
|
|
case 52 :
|
|
// InternalRDL.g:1:316: T__61
|
|
{
|
|
mT__61();
|
|
|
|
}
|
|
break;
|
|
case 53 :
|
|
// InternalRDL.g:1:322: T__62
|
|
{
|
|
mT__62();
|
|
|
|
}
|
|
break;
|
|
case 54 :
|
|
// InternalRDL.g:1:328: T__63
|
|
{
|
|
mT__63();
|
|
|
|
}
|
|
break;
|
|
case 55 :
|
|
// InternalRDL.g:1:334: T__64
|
|
{
|
|
mT__64();
|
|
|
|
}
|
|
break;
|
|
case 56 :
|
|
// InternalRDL.g:1:340: T__65
|
|
{
|
|
mT__65();
|
|
|
|
}
|
|
break;
|
|
case 57 :
|
|
// InternalRDL.g:1:346: T__66
|
|
{
|
|
mT__66();
|
|
|
|
}
|
|
break;
|
|
case 58 :
|
|
// InternalRDL.g:1:352: T__67
|
|
{
|
|
mT__67();
|
|
|
|
}
|
|
break;
|
|
case 59 :
|
|
// InternalRDL.g:1:358: T__68
|
|
{
|
|
mT__68();
|
|
|
|
}
|
|
break;
|
|
case 60 :
|
|
// InternalRDL.g:1:364: T__69
|
|
{
|
|
mT__69();
|
|
|
|
}
|
|
break;
|
|
case 61 :
|
|
// InternalRDL.g:1:370: T__70
|
|
{
|
|
mT__70();
|
|
|
|
}
|
|
break;
|
|
case 62 :
|
|
// InternalRDL.g:1:376: T__71
|
|
{
|
|
mT__71();
|
|
|
|
}
|
|
break;
|
|
case 63 :
|
|
// InternalRDL.g:1:382: T__72
|
|
{
|
|
mT__72();
|
|
|
|
}
|
|
break;
|
|
case 64 :
|
|
// InternalRDL.g:1:388: T__73
|
|
{
|
|
mT__73();
|
|
|
|
}
|
|
break;
|
|
case 65 :
|
|
// InternalRDL.g:1:394: T__74
|
|
{
|
|
mT__74();
|
|
|
|
}
|
|
break;
|
|
case 66 :
|
|
// InternalRDL.g:1:400: T__75
|
|
{
|
|
mT__75();
|
|
|
|
}
|
|
break;
|
|
case 67 :
|
|
// InternalRDL.g:1:406: T__76
|
|
{
|
|
mT__76();
|
|
|
|
}
|
|
break;
|
|
case 68 :
|
|
// InternalRDL.g:1:412: T__77
|
|
{
|
|
mT__77();
|
|
|
|
}
|
|
break;
|
|
case 69 :
|
|
// InternalRDL.g:1:418: T__78
|
|
{
|
|
mT__78();
|
|
|
|
}
|
|
break;
|
|
case 70 :
|
|
// InternalRDL.g:1:424: T__79
|
|
{
|
|
mT__79();
|
|
|
|
}
|
|
break;
|
|
case 71 :
|
|
// InternalRDL.g:1:430: T__80
|
|
{
|
|
mT__80();
|
|
|
|
}
|
|
break;
|
|
case 72 :
|
|
// InternalRDL.g:1:436: T__81
|
|
{
|
|
mT__81();
|
|
|
|
}
|
|
break;
|
|
case 73 :
|
|
// InternalRDL.g:1:442: T__82
|
|
{
|
|
mT__82();
|
|
|
|
}
|
|
break;
|
|
case 74 :
|
|
// InternalRDL.g:1:448: T__83
|
|
{
|
|
mT__83();
|
|
|
|
}
|
|
break;
|
|
case 75 :
|
|
// InternalRDL.g:1:454: T__84
|
|
{
|
|
mT__84();
|
|
|
|
}
|
|
break;
|
|
case 76 :
|
|
// InternalRDL.g:1:460: T__85
|
|
{
|
|
mT__85();
|
|
|
|
}
|
|
break;
|
|
case 77 :
|
|
// InternalRDL.g:1:466: T__86
|
|
{
|
|
mT__86();
|
|
|
|
}
|
|
break;
|
|
case 78 :
|
|
// InternalRDL.g:1:472: T__87
|
|
{
|
|
mT__87();
|
|
|
|
}
|
|
break;
|
|
case 79 :
|
|
// InternalRDL.g:1:478: T__88
|
|
{
|
|
mT__88();
|
|
|
|
}
|
|
break;
|
|
case 80 :
|
|
// InternalRDL.g:1:484: T__89
|
|
{
|
|
mT__89();
|
|
|
|
}
|
|
break;
|
|
case 81 :
|
|
// InternalRDL.g:1:490: T__90
|
|
{
|
|
mT__90();
|
|
|
|
}
|
|
break;
|
|
case 82 :
|
|
// InternalRDL.g:1:496: T__91
|
|
{
|
|
mT__91();
|
|
|
|
}
|
|
break;
|
|
case 83 :
|
|
// InternalRDL.g:1:502: T__92
|
|
{
|
|
mT__92();
|
|
|
|
}
|
|
break;
|
|
case 84 :
|
|
// InternalRDL.g:1:508: T__93
|
|
{
|
|
mT__93();
|
|
|
|
}
|
|
break;
|
|
case 85 :
|
|
// InternalRDL.g:1:514: T__94
|
|
{
|
|
mT__94();
|
|
|
|
}
|
|
break;
|
|
case 86 :
|
|
// InternalRDL.g:1:520: T__95
|
|
{
|
|
mT__95();
|
|
|
|
}
|
|
break;
|
|
case 87 :
|
|
// InternalRDL.g:1:526: T__96
|
|
{
|
|
mT__96();
|
|
|
|
}
|
|
break;
|
|
case 88 :
|
|
// InternalRDL.g:1:532: T__97
|
|
{
|
|
mT__97();
|
|
|
|
}
|
|
break;
|
|
case 89 :
|
|
// InternalRDL.g:1:538: T__98
|
|
{
|
|
mT__98();
|
|
|
|
}
|
|
break;
|
|
case 90 :
|
|
// InternalRDL.g:1:544: T__99
|
|
{
|
|
mT__99();
|
|
|
|
}
|
|
break;
|
|
case 91 :
|
|
// InternalRDL.g:1:550: T__100
|
|
{
|
|
mT__100();
|
|
|
|
}
|
|
break;
|
|
case 92 :
|
|
// InternalRDL.g:1:557: T__101
|
|
{
|
|
mT__101();
|
|
|
|
}
|
|
break;
|
|
case 93 :
|
|
// InternalRDL.g:1:564: T__102
|
|
{
|
|
mT__102();
|
|
|
|
}
|
|
break;
|
|
case 94 :
|
|
// InternalRDL.g:1:571: T__103
|
|
{
|
|
mT__103();
|
|
|
|
}
|
|
break;
|
|
case 95 :
|
|
// InternalRDL.g:1:578: T__104
|
|
{
|
|
mT__104();
|
|
|
|
}
|
|
break;
|
|
case 96 :
|
|
// InternalRDL.g:1:585: T__105
|
|
{
|
|
mT__105();
|
|
|
|
}
|
|
break;
|
|
case 97 :
|
|
// InternalRDL.g:1:592: T__106
|
|
{
|
|
mT__106();
|
|
|
|
}
|
|
break;
|
|
case 98 :
|
|
// InternalRDL.g:1:599: T__107
|
|
{
|
|
mT__107();
|
|
|
|
}
|
|
break;
|
|
case 99 :
|
|
// InternalRDL.g:1:606: T__108
|
|
{
|
|
mT__108();
|
|
|
|
}
|
|
break;
|
|
case 100 :
|
|
// InternalRDL.g:1:613: T__109
|
|
{
|
|
mT__109();
|
|
|
|
}
|
|
break;
|
|
case 101 :
|
|
// InternalRDL.g:1:620: T__110
|
|
{
|
|
mT__110();
|
|
|
|
}
|
|
break;
|
|
case 102 :
|
|
// InternalRDL.g:1:627: T__111
|
|
{
|
|
mT__111();
|
|
|
|
}
|
|
break;
|
|
case 103 :
|
|
// InternalRDL.g:1:634: T__112
|
|
{
|
|
mT__112();
|
|
|
|
}
|
|
break;
|
|
case 104 :
|
|
// InternalRDL.g:1:641: T__113
|
|
{
|
|
mT__113();
|
|
|
|
}
|
|
break;
|
|
case 105 :
|
|
// InternalRDL.g:1:648: T__114
|
|
{
|
|
mT__114();
|
|
|
|
}
|
|
break;
|
|
case 106 :
|
|
// InternalRDL.g:1:655: T__115
|
|
{
|
|
mT__115();
|
|
|
|
}
|
|
break;
|
|
case 107 :
|
|
// InternalRDL.g:1:662: T__116
|
|
{
|
|
mT__116();
|
|
|
|
}
|
|
break;
|
|
case 108 :
|
|
// InternalRDL.g:1:669: T__117
|
|
{
|
|
mT__117();
|
|
|
|
}
|
|
break;
|
|
case 109 :
|
|
// InternalRDL.g:1:676: T__118
|
|
{
|
|
mT__118();
|
|
|
|
}
|
|
break;
|
|
case 110 :
|
|
// InternalRDL.g:1:683: T__119
|
|
{
|
|
mT__119();
|
|
|
|
}
|
|
break;
|
|
case 111 :
|
|
// InternalRDL.g:1:690: T__120
|
|
{
|
|
mT__120();
|
|
|
|
}
|
|
break;
|
|
case 112 :
|
|
// InternalRDL.g:1:697: T__121
|
|
{
|
|
mT__121();
|
|
|
|
}
|
|
break;
|
|
case 113 :
|
|
// InternalRDL.g:1:704: T__122
|
|
{
|
|
mT__122();
|
|
|
|
}
|
|
break;
|
|
case 114 :
|
|
// InternalRDL.g:1:711: T__123
|
|
{
|
|
mT__123();
|
|
|
|
}
|
|
break;
|
|
case 115 :
|
|
// InternalRDL.g:1:718: T__124
|
|
{
|
|
mT__124();
|
|
|
|
}
|
|
break;
|
|
case 116 :
|
|
// InternalRDL.g:1:725: T__125
|
|
{
|
|
mT__125();
|
|
|
|
}
|
|
break;
|
|
case 117 :
|
|
// InternalRDL.g:1:732: T__126
|
|
{
|
|
mT__126();
|
|
|
|
}
|
|
break;
|
|
case 118 :
|
|
// InternalRDL.g:1:739: T__127
|
|
{
|
|
mT__127();
|
|
|
|
}
|
|
break;
|
|
case 119 :
|
|
// InternalRDL.g:1:746: T__128
|
|
{
|
|
mT__128();
|
|
|
|
}
|
|
break;
|
|
case 120 :
|
|
// InternalRDL.g:1:753: T__129
|
|
{
|
|
mT__129();
|
|
|
|
}
|
|
break;
|
|
case 121 :
|
|
// InternalRDL.g:1:760: T__130
|
|
{
|
|
mT__130();
|
|
|
|
}
|
|
break;
|
|
case 122 :
|
|
// InternalRDL.g:1:767: T__131
|
|
{
|
|
mT__131();
|
|
|
|
}
|
|
break;
|
|
case 123 :
|
|
// InternalRDL.g:1:774: T__132
|
|
{
|
|
mT__132();
|
|
|
|
}
|
|
break;
|
|
case 124 :
|
|
// InternalRDL.g:1:781: RULE_ID
|
|
{
|
|
mRULE_ID();
|
|
|
|
}
|
|
break;
|
|
case 125 :
|
|
// InternalRDL.g:1:789: RULE_WS
|
|
{
|
|
mRULE_WS();
|
|
|
|
}
|
|
break;
|
|
case 126 :
|
|
// InternalRDL.g:1:797: RULE_ML_COMMENT
|
|
{
|
|
mRULE_ML_COMMENT();
|
|
|
|
}
|
|
break;
|
|
case 127 :
|
|
// InternalRDL.g:1:813: RULE_SL_COMMENT
|
|
{
|
|
mRULE_SL_COMMENT();
|
|
|
|
}
|
|
break;
|
|
case 128 :
|
|
// InternalRDL.g:1:829: RULE_NUM
|
|
{
|
|
mRULE_NUM();
|
|
|
|
}
|
|
break;
|
|
case 129 :
|
|
// InternalRDL.g:1:838: RULE_STR
|
|
{
|
|
mRULE_STR();
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
protected DFA21 dfa21 = new DFA21(this);
|
|
protected DFA23 dfa23 = new DFA23(this);
|
|
static final String DFA21_eotS =
|
|
"\1\uffff\2\5\7\uffff";
|
|
static final String DFA21_eofS =
|
|
"\12\uffff";
|
|
static final String DFA21_minS =
|
|
"\1\60\2\47\1\uffff\1\142\5\uffff";
|
|
static final String DFA21_maxS =
|
|
"\1\71\1\170\1\71\1\uffff\1\157\5\uffff";
|
|
static final String DFA21_acceptS =
|
|
"\3\uffff\1\5\1\uffff\1\6\1\4\1\3\1\2\1\1";
|
|
static final String DFA21_specialS =
|
|
"\12\uffff}>";
|
|
static final String[] DFA21_transitionS = {
|
|
"\1\1\11\2",
|
|
"\1\4\10\uffff\12\2\76\uffff\1\3",
|
|
"\1\4\10\uffff\12\2",
|
|
"",
|
|
"\1\11\1\uffff\1\6\3\uffff\1\7\6\uffff\1\10",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
""
|
|
};
|
|
|
|
static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
|
|
static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
|
|
static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
|
|
static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
|
|
static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
|
|
static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
|
|
static final short[][] DFA21_transition;
|
|
|
|
static {
|
|
int numStates = DFA21_transitionS.length;
|
|
DFA21_transition = new short[numStates][];
|
|
for (int i=0; i<numStates; i++) {
|
|
DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
|
|
}
|
|
}
|
|
|
|
class DFA21 extends DFA {
|
|
|
|
public DFA21(BaseRecognizer recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 21;
|
|
this.eot = DFA21_eot;
|
|
this.eof = DFA21_eof;
|
|
this.min = DFA21_min;
|
|
this.max = DFA21_max;
|
|
this.accept = DFA21_accept;
|
|
this.special = DFA21_special;
|
|
this.transition = DFA21_transition;
|
|
}
|
|
public String getDescription() {
|
|
return "7650:12: ( ( '0' .. '9' )+ '\\'b' ( '0' | '1' | '_' )+ | ( '0' .. '9' )+ '\\'o' ( '0' .. '7' | '_' )+ | ( '0' .. '9' )+ '\\'h' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ | ( '0' .. '9' )+ '\\'d' ( '0' .. '9' | '_' )+ | '0x' ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ | ( '0' .. '9' )+ )";
|
|
}
|
|
}
|
|
static final String DFA23_eotS =
|
|
"\1\uffff\4\44\1\101\2\44\1\112\14\44\25\uffff\2\44\1\153\4\44\1\161\16\44\1\u0087\1\uffff\6\44\1\u0092\1\u0093\1\uffff\1\u0098\27\44\1\uffff\7\44\1\uffff\5\44\1\uffff\10\44\1\u00c9\6\44\1\u00d4\1\u00d5\4\44\1\uffff\11\44\1\u00e3\2\uffff\4\44\1\uffff\40\44\1\u010a\3\44\1\u010e\2\44\1\u0111\1\u0112\7\44\1\uffff\12\44\2\uffff\1\44\1\u0126\1\44\1\u0128\3\44\1\u012c\1\u0131\4\44\1\uffff\4\44\1\u013d\1\u013e\1\44\1\u0142\1\u0143\11\44\1\u014e\2\44\1\u0151\1\44\1\u0153\1\u0154\2\44\1\u0157\1\u0158\10\44\1\u0161\1\uffff\1\u0162\1\u0163\1\44\1\uffff\2\44\2\uffff\11\44\1\u0170\1\44\1\u0172\1\u0173\5\44\1\u017a\1\uffff\1\44\1\uffff\1\u017e\1\u017f\1\44\1\uffff\4\44\1\uffff\3\44\1\u0188\1\u0189\1\u018a\1\u018b\4\44\2\uffff\3\44\2\uffff\1\44\1\u0194\4\44\1\u0199\3\44\1\uffff\2\44\1\uffff\1\u019f\2\uffff\2\44\2\uffff\4\44\1\u01a6\1\u01a8\1\u01aa\1\44\3\uffff\1\u01ad\1\44\1\u01af\5\44\1\u01b5\3\44\1\uffff\1\44\2\uffff\6\44\1\uffff\3\44\2\uffff\10\44\4\uffff\1\44\1\u01cd\6\44\1\uffff\4\44\1\uffff\1\44\1\u01d9\1\u01da\2\44\1\uffff\6\44\1\uffff\1\44\1\uffff\1\44\1\uffff\2\44\1\uffff\1\44\1\uffff\1\u01e8\1\44\1\u01ea\2\44\1\uffff\1\u01ed\2\44\1\u01f0\3\44\1\u01f4\3\44\1\u01f9\7\44\1\u0201\3\44\1\uffff\6\44\1\u020b\1\u020c\3\44\2\uffff\6\44\1\u0216\5\44\1\u021c\1\uffff\1\44\1\uffff\1\u021e\1\44\1\uffff\2\44\1\uffff\3\44\1\uffff\1\u0225\1\u0226\1\44\1\u0228\1\uffff\7\44\1\uffff\1\44\1\u0231\1\u0232\1\u0233\1\44\1\u0235\2\44\1\u0238\2\uffff\3\44\1\u023c\4\44\1\u0241\1\uffff\1\44\1\u0243\3\44\1\uffff\1\u0247\1\uffff\1\u0248\1\44\1\u024a\1\44\1\u024c\1\44\2\uffff\1\44\1\uffff\2\44\1\u0251\1\u0252\1\u0253\3\44\3\uffff\1\44\1\uffff\1\u0258\1\u0259\1\uffff\1\u025a\1\44\1\u025c\1\uffff\1\44\1\u025e\1\u025f\1\44\1\uffff\1\u0261\1\uffff\3\44\2\uffff\1\u0265\1\uffff\1\u0266\1\uffff\3\44\1\u026a\3\uffff\3\44\1\u026e\3\uffff\1\44\1\uffff\1\44\2\uffff\1\u0271\1\uffff\1\u0272\1\u0273\1\44\2\uffff\1\u0275\1\u0276\1\u0277\1\uffff\2\44\1\u027a\1\uffff\1\u027b\1\44\3\uffff\1\u027d\3\uffff\1\u027e\1\44\2\uffff\1\u0280\2\uffff\1\u0281\2\uffff";
|
|
static final String DFA23_eofS =
|
|
"\u0282\uffff";
|
|
static final String DFA23_minS =
|
|
"\1\11\2\141\1\151\1\143\1\60\1\141\1\145\1\60\1\141\1\156\1\162\1\157\1\154\1\156\1\145\1\141\1\156\1\150\1\157\1\116\21\uffff\1\52\3\uffff\1\151\1\147\1\60\1\141\1\156\1\164\1\155\1\60\1\147\1\156\1\157\1\147\1\151\1\144\1\151\1\142\1\144\1\171\1\143\1\146\1\145\1\154\1\60\1\uffff\1\145\2\154\1\143\1\156\1\143\2\60\1\uffff\1\60\1\154\1\143\2\145\1\162\1\155\1\165\1\157\1\162\1\141\2\164\1\142\1\166\1\142\1\163\1\144\1\162\1\165\1\160\1\145\1\163\1\104\1\uffff\1\151\1\143\1\156\1\147\1\145\1\157\1\143\1\uffff\1\162\1\143\1\165\1\142\1\145\1\uffff\1\164\1\145\1\163\1\154\1\150\1\145\1\144\1\162\1\60\1\141\1\151\1\145\1\156\1\151\1\145\2\60\1\145\1\164\1\144\1\162\1\uffff\1\154\1\163\1\154\1\143\1\162\1\141\1\164\1\154\1\145\1\60\2\uffff\1\145\1\154\1\156\1\141\1\uffff\1\164\1\145\1\162\1\144\1\162\1\145\1\156\1\160\1\151\1\143\1\145\1\157\1\142\1\155\1\145\1\164\1\60\1\145\1\60\1\153\4\145\1\143\1\160\1\145\1\105\1\156\1\153\1\141\1\154\1\60\1\144\1\143\1\145\1\60\1\162\1\145\2\60\1\144\1\164\2\145\1\156\1\147\1\145\1\uffff\1\156\1\163\1\164\1\144\1\143\1\166\1\163\2\151\1\154\2\uffff\1\164\1\60\1\163\1\60\1\144\1\145\1\141\2\60\1\165\1\143\1\162\1\164\1\uffff\1\164\1\162\1\141\1\163\2\60\1\162\2\60\1\146\1\144\1\164\1\141\1\146\1\153\1\170\1\144\1\154\1\60\1\162\1\154\1\60\1\154\2\60\1\162\1\163\2\60\2\145\1\144\1\106\1\147\1\171\1\154\1\145\1\60\1\uffff\2\60\1\144\1\uffff\1\141\1\162\2\uffff\1\147\1\151\1\141\2\144\1\145\1\141\1\163\1\155\1\60\1\145\2\60\1\145\1\163\1\154\1\144\1\151\1\60\1\uffff\1\145\1\uffff\2\60\1\154\1\uffff\1\151\2\141\1\150\1\uffff\1\154\1\157\1\145\4\60\1\142\1\153\1\141\1\156\2\uffff\1\156\1\151\1\141\2\uffff\1\154\1\60\1\145\1\143\1\156\1\137\1\60\1\164\2\145\1\uffff\1\156\1\145\1\uffff\1\60\2\uffff\1\146\1\150\2\uffff\1\144\1\162\1\147\1\111\3\60\1\160\3\uffff\1\60\1\164\1\60\1\145\1\143\1\156\1\147\1\151\1\60\1\160\1\163\1\145\1\uffff\1\162\2\uffff\1\150\1\167\1\145\1\164\1\147\1\151\1\uffff\1\164\1\162\1\151\2\uffff\1\151\1\144\1\154\1\164\1\162\1\164\1\155\1\163\4\uffff\1\154\1\60\1\163\2\141\1\144\1\154\1\157\1\uffff\1\162\1\164\1\145\1\162\1\uffff\1\142\2\60\1\141\1\145\1\uffff\1\154\1\157\1\145\1\164\1\145\1\116\1\uffff\1\151\1\uffff\1\151\1\uffff\1\165\1\170\1\uffff\1\145\1\uffff\1\60\1\153\1\60\1\145\1\141\1\uffff\1\60\1\151\1\156\1\60\1\151\1\157\1\151\1\60\1\150\1\156\1\147\1\60\1\145\1\144\1\147\1\164\2\165\1\145\1\60\1\160\1\164\1\145\1\uffff\1\153\1\142\1\154\1\164\1\165\1\167\2\60\1\156\1\145\1\165\2\uffff\1\154\1\156\1\157\1\154\1\156\1\171\1\60\1\105\1\164\1\144\1\154\1\164\1\60\1\uffff\1\171\1\uffff\1\60\1\156\1\uffff\1\156\1\164\1\uffff\1\147\1\167\1\144\1\uffff\2\60\1\156\1\60\1\uffff\1\163\1\164\1\156\1\150\1\145\1\162\1\163\1\uffff\1\141\3\60\1\154\1\60\1\150\1\145\1\60\2\uffff\1\164\2\163\1\60\1\144\1\167\1\144\1\143\1\60\1\uffff\1\104\1\60\1\164\1\163\1\142\1\uffff\1\60\1\uffff\1\60\1\147\1\60\1\150\1\60\1\164\2\uffff\1\141\1\uffff\1\145\1\150\3\60\1\141\1\150\1\162\3\uffff\1\145\1\uffff\2\60\1\uffff\1\60\1\145\1\60\1\uffff\1\151\2\60\1\145\1\uffff\1\60\1\uffff\1\150\1\145\1\165\2\uffff\1\60\1\uffff\1\60\1\uffff\1\150\1\154\1\164\1\60\3\uffff\1\164\1\157\1\145\1\60\3\uffff\1\164\1\uffff\1\141\2\uffff\1\60\1\uffff\2\60\1\163\2\uffff\3\60\1\uffff\1\145\1\154\1\60\1\uffff\1\60\1\156\3\uffff\1\60\3\uffff\1\60\1\144\2\uffff\1\60\2\uffff\1\60\2\uffff";
|
|
static final String DFA23_maxS =
|
|
"\1\175\1\171\1\165\1\162\1\163\1\172\1\165\1\157\1\172\1\167\1\156\1\166\1\157\1\160\1\170\2\163\1\156\1\171\1\162\1\116\21\uffff\1\57\3\uffff\1\162\1\156\1\172\1\141\1\156\1\164\1\155\1\172\1\170\1\156\1\164\1\147\1\151\1\144\1\154\1\142\1\144\1\171\1\164\1\163\1\166\1\154\1\172\1\uffff\1\145\2\154\1\163\1\156\1\163\2\172\1\uffff\1\172\1\154\1\164\2\145\1\162\2\165\1\157\1\162\1\165\2\164\1\142\1\166\1\142\1\163\1\144\1\162\1\165\1\160\1\157\1\163\1\104\1\uffff\1\151\1\143\1\156\1\147\1\145\1\157\1\143\1\uffff\1\162\1\143\1\165\1\142\1\145\1\uffff\1\164\1\145\1\163\1\154\1\150\1\145\1\144\1\162\1\172\1\147\1\151\1\145\1\156\1\151\1\145\2\172\1\145\1\164\1\144\1\162\1\uffff\1\154\1\163\1\154\1\143\1\162\1\141\1\164\1\154\1\145\1\172\2\uffff\1\145\1\154\1\156\1\141\1\uffff\1\164\2\162\1\144\1\162\1\145\1\156\1\160\1\151\1\143\1\145\1\157\1\142\1\155\1\145\1\164\1\60\1\145\1\60\1\153\4\145\1\143\1\160\1\145\1\105\1\156\1\153\1\141\1\154\1\172\1\144\1\143\1\145\1\172\1\162\1\145\2\172\1\144\1\164\2\145\1\156\1\147\1\155\1\uffff\1\156\1\163\1\164\1\144\1\143\1\166\1\163\2\151\1\154\2\uffff\1\164\1\172\1\163\1\172\1\144\1\145\1\141\2\172\1\165\1\164\1\162\1\164\1\uffff\1\164\1\162\1\141\1\163\2\172\1\162\2\172\1\146\1\144\1\164\1\157\1\146\1\153\1\170\1\144\1\154\1\172\1\162\1\154\1\172\1\154\2\172\1\162\1\163\2\172\2\145\1\144\1\106\1\147\1\171\1\154\1\145\1\172\1\uffff\2\172\1\144\1\uffff\1\141\1\162\2\uffff\1\147\1\151\1\141\2\144\1\145\1\141\1\163\1\155\1\172\1\145\2\172\1\145\1\163\1\154\1\144\1\151\1\172\1\uffff\1\145\1\uffff\2\172\1\154\1\uffff\1\151\2\141\1\150\1\uffff\1\154\1\157\1\145\4\172\1\142\1\153\1\141\1\156\2\uffff\1\156\1\151\1\141\2\uffff\1\154\1\172\1\145\1\143\1\156\1\137\1\172\1\164\2\145\1\uffff\1\156\1\145\1\uffff\1\172\2\uffff\1\146\1\150\2\uffff\1\144\1\162\1\147\1\111\3\172\1\160\3\uffff\1\172\1\164\1\172\1\145\1\143\1\156\1\147\1\151\1\172\1\160\1\163\1\145\1\uffff\1\162\2\uffff\1\154\1\167\1\145\1\164\1\147\1\151\1\uffff\1\164\1\162\1\151\2\uffff\1\151\1\144\1\154\1\164\1\162\1\164\1\155\1\163\4\uffff\1\154\1\172\1\163\2\141\1\144\1\154\1\157\1\uffff\1\162\1\164\1\145\1\162\1\uffff\1\142\2\172\1\141\1\145\1\uffff\1\154\1\157\1\145\1\164\1\145\1\116\1\uffff\1\151\1\uffff\1\151\1\uffff\1\165\1\170\1\uffff\1\145\1\uffff\1\172\1\153\1\172\1\145\1\141\1\uffff\1\172\1\151\1\156\1\172\1\151\1\157\1\151\1\172\1\150\1\156\1\147\1\172\1\145\1\144\1\147\1\164\2\165\1\145\1\172\1\160\1\164\1\145\1\uffff\1\153\1\142\1\154\1\164\1\165\1\167\2\172\1\156\1\145\1\165\2\uffff\1\154\1\156\1\157\1\154\1\156\1\171\1\172\1\105\1\164\1\144\1\154\1\164\1\172\1\uffff\1\171\1\uffff\1\172\1\156\1\uffff\1\156\1\164\1\uffff\1\147\1\167\1\144\1\uffff\2\172\1\156\1\172\1\uffff\1\163\1\164\1\156\1\150\1\145\1\162\1\163\1\uffff\1\141\3\172\1\154\1\172\1\150\1\145\1\172\2\uffff\1\164\2\163\1\172\1\144\1\167\1\144\1\143\1\172\1\uffff\1\104\1\172\1\164\1\163\1\142\1\uffff\1\172\1\uffff\1\172\1\147\1\172\1\150\1\172\1\164\2\uffff\1\141\1\uffff\1\145\1\150\3\172\1\141\1\150\1\162\3\uffff\1\145\1\uffff\2\172\1\uffff\1\172\1\145\1\172\1\uffff\1\151\2\172\1\145\1\uffff\1\172\1\uffff\1\150\1\145\1\165\2\uffff\1\172\1\uffff\1\172\1\uffff\1\150\1\154\1\164\1\172\3\uffff\1\164\1\157\1\145\1\172\3\uffff\1\164\1\uffff\1\141\2\uffff\1\172\1\uffff\2\172\1\163\2\uffff\3\172\1\uffff\1\145\1\154\1\172\1\uffff\1\172\1\156\3\uffff\1\172\3\uffff\1\172\1\144\2\uffff\1\172\2\uffff\1\172\2\uffff";
|
|
static final String DFA23_acceptS =
|
|
"\25\uffff\1\146\1\150\1\151\1\152\1\154\1\157\1\161\1\162\1\163\1\164\1\165\1\166\1\167\1\170\1\171\1\174\1\175\1\uffff\1\176\1\u0080\1\u0081\27\uffff\1\133\10\uffff\1\134\30\uffff\1\177\7\uffff\1\107\5\uffff\1\135\25\uffff\1\131\12\uffff\1\22\1\132\4\uffff\1\110\60\uffff\1\12\12\uffff\1\5\1\10\15\uffff\1\23\46\uffff\1\24\3\uffff\1\55\2\uffff\1\13\1\125\23\uffff\1\16\1\uffff\1\17\3\uffff\1\14\4\uffff\1\66\13\uffff\1\124\1\34\3\uffff\1\65\1\36\12\uffff\1\172\2\uffff\1\54\1\uffff\1\53\1\116\2\uffff\1\127\1\153\10\uffff\1\25\1\30\1\31\14\uffff\1\160\1\uffff\1\35\1\56\6\uffff\1\44\3\uffff\1\7\1\130\10\uffff\1\20\1\21\1\26\1\27\10\uffff\1\37\4\uffff\1\115\5\uffff\1\144\6\uffff\1\1\1\uffff\1\32\1\uffff\1\11\2\uffff\1\52\1\uffff\1\2\5\uffff\1\51\27\uffff\1\121\13\uffff\1\113\1\117\15\uffff\1\142\1\uffff\1\3\2\uffff\1\4\2\uffff\1\15\3\uffff\1\6\4\uffff\1\47\7\uffff\1\155\11\uffff\1\40\1\136\11\uffff\1\141\5\uffff\1\73\1\uffff\1\143\6\uffff\1\103\1\137\1\uffff\1\50\10\uffff\1\100\1\120\1\122\1\uffff\1\101\2\uffff\1\41\3\uffff\1\173\4\uffff\1\147\1\uffff\1\33\3\uffff\1\145\1\46\1\uffff\1\102\1\uffff\1\62\4\uffff\1\140\1\70\1\72\4\uffff\1\67\1\71\1\156\1\uffff\1\43\1\uffff\1\64\1\75\1\uffff\1\126\3\uffff\1\111\1\61\3\uffff\1\104\3\uffff\1\123\2\uffff\1\112\1\105\1\63\1\uffff\1\106\1\114\1\60\2\uffff\1\77\1\57\1\uffff\1\42\1\74\1\uffff\1\45\1\76";
|
|
static final String DFA23_specialS =
|
|
"\u0282\uffff}>";
|
|
static final String[] DFA23_transitionS = {
|
|
"\2\45\2\uffff\1\45\22\uffff\1\45\1\uffff\1\51\2\uffff\1\36\2\uffff\1\47\2\uffff\1\35\1\33\1\42\1\43\1\46\12\50\1\41\1\30\1\47\1\31\2\uffff\1\34\24\44\1\24\5\44\1\37\1\44\1\40\1\uffff\1\44\1\25\1\4\1\3\1\15\1\7\1\16\1\6\1\44\1\11\1\12\2\44\1\17\1\20\1\2\1\13\1\23\1\44\1\5\1\1\1\22\1\21\1\44\1\10\1\14\2\44\1\26\1\32\1\27",
|
|
"\1\57\6\uffff\1\55\1\53\12\uffff\1\52\2\uffff\1\54\1\uffff\1\56",
|
|
"\1\61\3\uffff\1\62\11\uffff\1\63\5\uffff\1\60",
|
|
"\1\65\5\uffff\1\64\2\uffff\1\66",
|
|
"\1\74\1\67\7\uffff\1\70\1\uffff\1\72\3\uffff\1\71\1\73",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\2\44\1\77\1\44\1\75\15\44\1\76\3\44\1\100\3\44",
|
|
"\1\103\7\uffff\1\102\13\uffff\1\104",
|
|
"\1\105\11\uffff\1\106",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\4\44\1\110\11\44\1\107\2\44\1\111\10\44",
|
|
"\1\114\25\uffff\1\113",
|
|
"\1\115",
|
|
"\1\116\3\uffff\1\117",
|
|
"\1\120",
|
|
"\1\123\2\uffff\1\121\1\122",
|
|
"\1\125\3\uffff\1\124\5\uffff\1\126",
|
|
"\1\131\3\uffff\1\127\11\uffff\1\130",
|
|
"\1\133\21\uffff\1\132",
|
|
"\1\134",
|
|
"\1\135\11\uffff\1\136\6\uffff\1\137",
|
|
"\1\141\2\uffff\1\140",
|
|
"\1\142",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\47\4\uffff\1\143",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\145\10\uffff\1\144",
|
|
"\1\146\6\uffff\1\147",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\1\152\13\44\1\151\11\44\1\150\3\44",
|
|
"\1\154",
|
|
"\1\155",
|
|
"\1\156",
|
|
"\1\157",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\14\44\1\160\15\44",
|
|
"\1\163\20\uffff\1\162",
|
|
"\1\164",
|
|
"\1\165\4\uffff\1\166",
|
|
"\1\167",
|
|
"\1\170",
|
|
"\1\171",
|
|
"\1\173\2\uffff\1\172",
|
|
"\1\174",
|
|
"\1\175",
|
|
"\1\176",
|
|
"\1\u0080\20\uffff\1\177",
|
|
"\1\u0082\1\u0081\13\uffff\1\u0083",
|
|
"\1\u0084\20\uffff\1\u0085",
|
|
"\1\u0086",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0088",
|
|
"\1\u0089",
|
|
"\1\u008a",
|
|
"\1\u008c\2\uffff\1\u008d\14\uffff\1\u008b",
|
|
"\1\u008e",
|
|
"\1\u008f\17\uffff\1\u0090",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\13\44\1\u0091\16\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\2\44\1\u0095\1\44\1\u0096\7\44\1\u0097\5\44\1\u0094\7\44",
|
|
"\1\u0099",
|
|
"\1\u009b\20\uffff\1\u009a",
|
|
"\1\u009c",
|
|
"\1\u009d",
|
|
"\1\u009e",
|
|
"\1\u00a0\7\uffff\1\u009f",
|
|
"\1\u00a1",
|
|
"\1\u00a2",
|
|
"\1\u00a3",
|
|
"\1\u00a5\1\uffff\1\u00a4\21\uffff\1\u00a6",
|
|
"\1\u00a7",
|
|
"\1\u00a8",
|
|
"\1\u00a9",
|
|
"\1\u00aa",
|
|
"\1\u00ab",
|
|
"\1\u00ac",
|
|
"\1\u00ad",
|
|
"\1\u00ae",
|
|
"\1\u00af",
|
|
"\1\u00b0",
|
|
"\1\u00b1\11\uffff\1\u00b2",
|
|
"\1\u00b3",
|
|
"\1\u00b4",
|
|
"",
|
|
"\1\u00b5",
|
|
"\1\u00b6",
|
|
"\1\u00b7",
|
|
"\1\u00b8",
|
|
"\1\u00b9",
|
|
"\1\u00ba",
|
|
"\1\u00bb",
|
|
"",
|
|
"\1\u00bc",
|
|
"\1\u00bd",
|
|
"\1\u00be",
|
|
"\1\u00bf",
|
|
"\1\u00c0",
|
|
"",
|
|
"\1\u00c1",
|
|
"\1\u00c2",
|
|
"\1\u00c3",
|
|
"\1\u00c4",
|
|
"\1\u00c5",
|
|
"\1\u00c6",
|
|
"\1\u00c7",
|
|
"\1\u00c8",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u00cb\5\uffff\1\u00ca",
|
|
"\1\u00cc",
|
|
"\1\u00cd",
|
|
"\1\u00ce",
|
|
"\1\u00cf",
|
|
"\1\u00d0",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\1\u00d3\4\44\1\u00d1\20\44\1\u00d2\3\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u00d6",
|
|
"\1\u00d7",
|
|
"\1\u00d8",
|
|
"\1\u00d9",
|
|
"",
|
|
"\1\u00da",
|
|
"\1\u00db",
|
|
"\1\u00dc",
|
|
"\1\u00dd",
|
|
"\1\u00de",
|
|
"\1\u00df",
|
|
"\1\u00e0",
|
|
"\1\u00e1",
|
|
"\1\u00e2",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"\1\u00e4",
|
|
"\1\u00e5",
|
|
"\1\u00e6",
|
|
"\1\u00e7",
|
|
"",
|
|
"\1\u00e8",
|
|
"\1\u00ea\14\uffff\1\u00e9",
|
|
"\1\u00eb",
|
|
"\1\u00ec",
|
|
"\1\u00ed",
|
|
"\1\u00ee",
|
|
"\1\u00ef",
|
|
"\1\u00f0",
|
|
"\1\u00f1",
|
|
"\1\u00f2",
|
|
"\1\u00f3",
|
|
"\1\u00f4",
|
|
"\1\u00f5",
|
|
"\1\u00f6",
|
|
"\1\u00f7",
|
|
"\1\u00f8",
|
|
"\1\u00f9",
|
|
"\1\u00fa",
|
|
"\1\u00fb",
|
|
"\1\u00fc",
|
|
"\1\u00fd",
|
|
"\1\u00fe",
|
|
"\1\u00ff",
|
|
"\1\u0100",
|
|
"\1\u0101",
|
|
"\1\u0102",
|
|
"\1\u0103",
|
|
"\1\u0104",
|
|
"\1\u0105",
|
|
"\1\u0106",
|
|
"\1\u0107",
|
|
"\1\u0108",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\13\44\1\u0109\16\44",
|
|
"\1\u010b",
|
|
"\1\u010c",
|
|
"\1\u010d",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u010f",
|
|
"\1\u0110",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0113",
|
|
"\1\u0114",
|
|
"\1\u0115",
|
|
"\1\u0116",
|
|
"\1\u0117",
|
|
"\1\u0118",
|
|
"\1\u011a\7\uffff\1\u0119",
|
|
"",
|
|
"\1\u011b",
|
|
"\1\u011c",
|
|
"\1\u011d",
|
|
"\1\u011e",
|
|
"\1\u011f",
|
|
"\1\u0120",
|
|
"\1\u0121",
|
|
"\1\u0122",
|
|
"\1\u0123",
|
|
"\1\u0124",
|
|
"",
|
|
"",
|
|
"\1\u0125",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0127",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0129",
|
|
"\1\u012a",
|
|
"\1\u012b",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\22\44\1\u012f\1\u0130\1\44\1\u012e\1\u012d\3\44",
|
|
"\1\u0132",
|
|
"\1\u0133\20\uffff\1\u0134",
|
|
"\1\u0135",
|
|
"\1\u0136",
|
|
"",
|
|
"\1\u0137",
|
|
"\1\u0138",
|
|
"\1\u0139",
|
|
"\1\u013a",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\4\44\1\u013c\7\44\1\u013b\15\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u013f",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\25\44\1\u0141\1\u0140\3\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0144",
|
|
"\1\u0145",
|
|
"\1\u0146",
|
|
"\1\u0147\15\uffff\1\u0148",
|
|
"\1\u0149",
|
|
"\1\u014a",
|
|
"\1\u014b",
|
|
"\1\u014c",
|
|
"\1\u014d",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u014f",
|
|
"\1\u0150",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0152",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0155",
|
|
"\1\u0156",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0159",
|
|
"\1\u015a",
|
|
"\1\u015b",
|
|
"\1\u015c",
|
|
"\1\u015d",
|
|
"\1\u015e",
|
|
"\1\u015f",
|
|
"\1\u0160",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0164",
|
|
"",
|
|
"\1\u0165",
|
|
"\1\u0166",
|
|
"",
|
|
"",
|
|
"\1\u0167",
|
|
"\1\u0168",
|
|
"\1\u0169",
|
|
"\1\u016a",
|
|
"\1\u016b",
|
|
"\1\u016c",
|
|
"\1\u016d",
|
|
"\1\u016e",
|
|
"\1\u016f",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0171",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0174",
|
|
"\1\u0175",
|
|
"\1\u0176",
|
|
"\1\u0177",
|
|
"\1\u0178",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\22\44\1\u0179\7\44",
|
|
"",
|
|
"\1\u017b",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\u017c\1\uffff\26\44\1\u017d\3\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0180",
|
|
"",
|
|
"\1\u0181",
|
|
"\1\u0182",
|
|
"\1\u0183",
|
|
"\1\u0184",
|
|
"",
|
|
"\1\u0185",
|
|
"\1\u0186",
|
|
"\1\u0187",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u018c",
|
|
"\1\u018d",
|
|
"\1\u018e",
|
|
"\1\u018f",
|
|
"",
|
|
"",
|
|
"\1\u0190",
|
|
"\1\u0191",
|
|
"\1\u0192",
|
|
"",
|
|
"",
|
|
"\1\u0193",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0195",
|
|
"\1\u0196",
|
|
"\1\u0197",
|
|
"\1\u0198",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u019a",
|
|
"\1\u019b",
|
|
"\1\u019c",
|
|
"",
|
|
"\1\u019d",
|
|
"\1\u019e",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"\1\u01a0",
|
|
"\1\u01a1",
|
|
"",
|
|
"",
|
|
"\1\u01a2",
|
|
"\1\u01a3",
|
|
"\1\u01a4",
|
|
"\1\u01a5",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\1\44\1\u01a7\30\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\26\44\1\u01a9\3\44",
|
|
"\1\u01ab",
|
|
"",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\4\44\1\u01ac\25\44",
|
|
"\1\u01ae",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01b0",
|
|
"\1\u01b1",
|
|
"\1\u01b2",
|
|
"\1\u01b3",
|
|
"\1\u01b4",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01b6",
|
|
"\1\u01b7",
|
|
"\1\u01b8",
|
|
"",
|
|
"\1\u01b9",
|
|
"",
|
|
"",
|
|
"\1\u01ba\3\uffff\1\u01bb",
|
|
"\1\u01bc",
|
|
"\1\u01bd",
|
|
"\1\u01be",
|
|
"\1\u01bf",
|
|
"\1\u01c0",
|
|
"",
|
|
"\1\u01c1",
|
|
"\1\u01c2",
|
|
"\1\u01c3",
|
|
"",
|
|
"",
|
|
"\1\u01c4",
|
|
"\1\u01c5",
|
|
"\1\u01c6",
|
|
"\1\u01c7",
|
|
"\1\u01c8",
|
|
"\1\u01c9",
|
|
"\1\u01ca",
|
|
"\1\u01cb",
|
|
"",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\u01cc",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01ce",
|
|
"\1\u01cf",
|
|
"\1\u01d0",
|
|
"\1\u01d1",
|
|
"\1\u01d2",
|
|
"\1\u01d3",
|
|
"",
|
|
"\1\u01d4",
|
|
"\1\u01d5",
|
|
"\1\u01d6",
|
|
"\1\u01d7",
|
|
"",
|
|
"\1\u01d8",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01db",
|
|
"\1\u01dc",
|
|
"",
|
|
"\1\u01dd",
|
|
"\1\u01de",
|
|
"\1\u01df",
|
|
"\1\u01e0",
|
|
"\1\u01e1",
|
|
"\1\u01e2",
|
|
"",
|
|
"\1\u01e3",
|
|
"",
|
|
"\1\u01e4",
|
|
"",
|
|
"\1\u01e5",
|
|
"\1\u01e6",
|
|
"",
|
|
"\1\u01e7",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01e9",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01eb",
|
|
"\1\u01ec",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01ee",
|
|
"\1\u01ef",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01f1",
|
|
"\1\u01f2",
|
|
"\1\u01f3",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01f5",
|
|
"\1\u01f6",
|
|
"\1\u01f7",
|
|
"\12\44\7\uffff\27\44\1\u01f8\2\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u01fa",
|
|
"\1\u01fb",
|
|
"\1\u01fc",
|
|
"\1\u01fd",
|
|
"\1\u01fe",
|
|
"\1\u01ff",
|
|
"\1\u0200",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0202",
|
|
"\1\u0203",
|
|
"\1\u0204",
|
|
"",
|
|
"\1\u0205",
|
|
"\1\u0206",
|
|
"\1\u0207",
|
|
"\1\u0208",
|
|
"\1\u0209",
|
|
"\1\u020a",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u020d",
|
|
"\1\u020e",
|
|
"\1\u020f",
|
|
"",
|
|
"",
|
|
"\1\u0210",
|
|
"\1\u0211",
|
|
"\1\u0212",
|
|
"\1\u0213",
|
|
"\1\u0214",
|
|
"\1\u0215",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0217",
|
|
"\1\u0218",
|
|
"\1\u0219",
|
|
"\1\u021a",
|
|
"\1\u021b",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u021d",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u021f",
|
|
"",
|
|
"\1\u0220",
|
|
"\1\u0221",
|
|
"",
|
|
"\1\u0222",
|
|
"\1\u0223",
|
|
"\1\u0224",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0227",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0229",
|
|
"\1\u022a",
|
|
"\1\u022b",
|
|
"\1\u022c",
|
|
"\1\u022d",
|
|
"\1\u022e",
|
|
"\1\u022f",
|
|
"",
|
|
"\1\u0230",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0234",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0236",
|
|
"\1\u0237",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"\1\u0239",
|
|
"\1\u023a",
|
|
"\1\u023b",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u023d",
|
|
"\1\u023e",
|
|
"\1\u023f",
|
|
"\1\u0240",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0242",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0244",
|
|
"\1\u0245",
|
|
"\1\u0246",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0249",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u024b",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u024d",
|
|
"",
|
|
"",
|
|
"\1\u024e",
|
|
"",
|
|
"\1\u024f",
|
|
"\1\u0250",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0254",
|
|
"\1\u0255",
|
|
"\1\u0256",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\u0257",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u025b",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u025d",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0260",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0262",
|
|
"\1\u0263",
|
|
"\1\u0264",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0267",
|
|
"\1\u0268",
|
|
"\1\u0269",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\u026b",
|
|
"\1\u026c",
|
|
"\1\u026d",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"",
|
|
"\1\u026f",
|
|
"",
|
|
"\1\u0270",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u0274",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\1\u0278",
|
|
"\1\u0279",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u027c",
|
|
"",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"\1\u027f",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
"",
|
|
"\12\44\7\uffff\32\44\4\uffff\1\44\1\uffff\32\44",
|
|
"",
|
|
""
|
|
};
|
|
|
|
static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS);
|
|
static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS);
|
|
static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS);
|
|
static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS);
|
|
static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS);
|
|
static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS);
|
|
static final short[][] DFA23_transition;
|
|
|
|
static {
|
|
int numStates = DFA23_transitionS.length;
|
|
DFA23_transition = new short[numStates][];
|
|
for (int i=0; i<numStates; i++) {
|
|
DFA23_transition[i] = DFA.unpackEncodedString(DFA23_transitionS[i]);
|
|
}
|
|
}
|
|
|
|
class DFA23 extends DFA {
|
|
|
|
public DFA23(BaseRecognizer recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 23;
|
|
this.eot = DFA23_eot;
|
|
this.eof = DFA23_eof;
|
|
this.min = DFA23_min;
|
|
this.max = DFA23_max;
|
|
this.accept = DFA23_accept;
|
|
this.special = DFA23_special;
|
|
this.transition = DFA23_transition;
|
|
}
|
|
public String getDescription() {
|
|
return "1:1: Tokens : ( T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | T__123 | T__124 | T__125 | T__126 | T__127 | T__128 | T__129 | T__130 | T__131 | T__132 | RULE_ID | RULE_WS | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_NUM | RULE_STR );";
|
|
}
|
|
}
|
|
|
|
|
|
} |