~ubuntu-branches/debian/sid/kdevelop/sid

if ( _cnt521>=1 ) { goto _loop521; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

998

}

999

1000

_cnt521++;

1001

}

1002

_loop521:;

1003

} // ( ... )+

1004

{

1005

switch ( LA(1)) {

1006

case 0x23 /* '#' */ :

1007

{

1008

match('#' /* charlit */ );

1009

mBASED_INTEGER(false);

1010

{

1011

switch ( LA(1)) {

1012

case 0x2e /* '.' */ :

1013

{

1014

match('.' /* charlit */ );

1015

mBASED_INTEGER(false);

1016

break;

1017

}

1018

case 0x23 /* '#' */ :

1019

{

1020

break;

1021

}

1022

default:

1023

{

1024

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1025

}

1026

}

1027

}

1028

match('#' /* charlit */ );

1029

break;

1030

}

1031

case 0x5f /* '_' */ :

1032

{

1033

{ // ( ... )+

1034

int _cnt527=0;

1035

for (;;) {

1036

if ((LA(1) == 0x5f /* '_' */ )) {

1037

match('_' /* charlit */ );

1038

{ // ( ... )+

1039

int _cnt526=0;

1040

for (;;) {

1041

if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {

1042

mDIGIT(false);

1043

}

1044

else {

1045

if ( _cnt526>=1 ) { goto _loop526; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

1046

}

1047

1048

_cnt526++;

1049

}

1050

_loop526:;

1051

} // ( ... )+

1052

}

1053

else {

1054

if ( _cnt527>=1 ) { goto _loop527; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

1055

}

1056

1057

_cnt527++;

1058

}

1059

_loop527:;

1060

} // ( ... )+

1061

break;

1062

}

1063

default:

1064

{

1065

}

1066

}

1067

}

1068

{

1069

if (((LA(1) == 0x2e /* '.' */ || LA(1) == 0x65 /* 'e' */ ))&&( LA(2)!='.' )) {

1070

{

1071

switch ( LA(1)) {

1072

case 0x2e /* '.' */ :

1073

{

1074

match('.' /* charlit */ );

1075

{ // ( ... )+

1076

int _cnt531=0;

1077

for (;;) {

1078

if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {

1079

mDIGIT(false);

1080

}

1081

else {

1082

if ( _cnt531>=1 ) { goto _loop531; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

1083

}

1084

1085

_cnt531++;

1086

}

1087

_loop531:;

1088

} // ( ... )+

1089

{ // ( ... )*

1090

for (;;) {

1091

if ((LA(1) == 0x5f /* '_' */ )) {

1092

match('_' /* charlit */ );

1093

{ // ( ... )+

1094

int _cnt534=0;

1095

for (;;) {

1096

if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {

1097

mDIGIT(false);

1098

}

1099

else {

1100

if ( _cnt534>=1 ) { goto _loop534; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

1101

}

1102

1103

_cnt534++;

1104

}

1105

_loop534:;

1106

} // ( ... )+

1107

}

1108

else {

1109

goto _loop535;

1110

}

1111

1112

}

1113

_loop535:;

1114

} // ( ... )*

1115

{

1116

if ((LA(1) == 0x65 /* 'e' */ )) {

1117

mEXPONENT(false);

1118

}

1119

else {

1120

}

1121

1122

}

1123

break;

1124

}

1125

case 0x65 /* 'e' */ :

1126

{

1127

mEXPONENT(false);

1128

break;

1129

}

1130

default:

1131

{

1132

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1133

}

1134

}

1135

}

1136

}

1137

else {

1138

}

1139

1140

}

1141

#line 1945 "ada.g"

1142

lastTokenWasTicCompatible=false;

1143

#line 1144 "AdaLexer.cpp"

1144

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1145

_token = makeToken(_ttype);

1146

_token->setText(text.substr(_begin, text.length()-_begin));

1147

}

1148

_returnToken = _token;

1149

_saveIndex=0;

1150

}

1151

1152

void AdaLexer::mDIGIT(bool _createToken) {

1153

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1154

_ttype = DIGIT;

1155

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1156

1157

{

1158

matchRange('0','9');

1159

}

1160

#line 1950 "ada.g"

1161

lastTokenWasTicCompatible=false;

1162

#line 1163 "AdaLexer.cpp"

1163

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1164

_token = makeToken(_ttype);

1165

_token->setText(text.substr(_begin, text.length()-_begin));

1166

}

1167

_returnToken = _token;

1168

_saveIndex=0;

1169

}

1170

1171

void AdaLexer::mBASED_INTEGER(bool _createToken) {

1172

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1173

_ttype = BASED_INTEGER;

1174

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1175

1176

{

1177

mEXTENDED_DIGIT(false);

1178

}

1179

{ // ( ... )*

1180

for (;;) {

1181

if ((_tokenSet_2.member(LA(1)))) {

1182

{

1183

switch ( LA(1)) {

1184

case 0x5f /* '_' */ :

1185

{

1186

match('_' /* charlit */ );

1187

break;

1188

}

1189

case 0x30 /* '0' */ :

1190

case 0x31 /* '1' */ :

1191

case 0x32 /* '2' */ :

1192

case 0x33 /* '3' */ :

1193

case 0x34 /* '4' */ :

1194

case 0x35 /* '5' */ :

1195

case 0x36 /* '6' */ :

1196

case 0x37 /* '7' */ :

1197

case 0x38 /* '8' */ :

1198

case 0x39 /* '9' */ :

1199

case 0x61 /* 'a' */ :

1200

case 0x62 /* 'b' */ :

1201

case 0x63 /* 'c' */ :

1202

case 0x64 /* 'd' */ :

1203

case 0x65 /* 'e' */ :

1204

case 0x66 /* 'f' */ :

1205

{

1206

break;

1207

}

1208

default:

1209

{

1210

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1211

}

1212

}

1213

}

1214

mEXTENDED_DIGIT(false);

1215

}

1216

else {

1217

goto _loop550;

1218

}

1219

1220

}

1221

_loop550:;

1222

} // ( ... )*

1223

#line 1959 "ada.g"

1224

lastTokenWasTicCompatible=false;

1225

#line 1226 "AdaLexer.cpp"

1226

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1227

_token = makeToken(_ttype);

1228

_token->setText(text.substr(_begin, text.length()-_begin));

1229

}

1230

_returnToken = _token;

1231

_saveIndex=0;

1232

}

1233

1234

void AdaLexer::mEXPONENT(bool _createToken) {

1235

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1236

_ttype = EXPONENT;

1237

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1238

1239

{

1240

match('e' /* charlit */ );

1241

}

1242

{

1243

switch ( LA(1)) {

1244

case 0x2b /* '+' */ :

1245

{

1246

match('+' /* charlit */ );

1247

break;

1248

}

1249

case 0x2d /* '-' */ :

1250

{

1251

match('-' /* charlit */ );

1252

break;

1253

}

1254

case 0x30 /* '0' */ :

1255

case 0x31 /* '1' */ :

1256

case 0x32 /* '2' */ :

1257

case 0x33 /* '3' */ :

1258

case 0x34 /* '4' */ :

1259

case 0x35 /* '5' */ :

1260

case 0x36 /* '6' */ :

1261

case 0x37 /* '7' */ :

1262

case 0x38 /* '8' */ :

1263

case 0x39 /* '9' */ :

1264

{

1265

break;

1266

}

1267

default:

1268

{

1269

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1270

}

1271

}

1272

}

1273

{ // ( ... )+

1274

int _cnt543=0;

1275

for (;;) {

1276

if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {

1277

mDIGIT(false);

1278

}

1279

else {

1280

if ( _cnt543>=1 ) { goto _loop543; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}

1281

}

1282

1283

_cnt543++;

1284

}

1285

_loop543:;

1286

} // ( ... )+

1287

#line 1953 "ada.g"

1288

lastTokenWasTicCompatible=false;

1289

#line 1290 "AdaLexer.cpp"

1290

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1291

_token = makeToken(_ttype);

1292

_token->setText(text.substr(_begin, text.length()-_begin));

1293

}

1294

_returnToken = _token;

1295

_saveIndex=0;

1296

}

1297

1298

void AdaLexer::mEXTENDED_DIGIT(bool _createToken) {

1299

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1300

_ttype = EXTENDED_DIGIT;

1301

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1302

1303

{

1304

switch ( LA(1)) {

1305

case 0x30 /* '0' */ :

1306

case 0x31 /* '1' */ :

1307

case 0x32 /* '2' */ :

1308

case 0x33 /* '3' */ :

1309

case 0x34 /* '4' */ :

1310

case 0x35 /* '5' */ :

1311

case 0x36 /* '6' */ :

1312

case 0x37 /* '7' */ :

1313

case 0x38 /* '8' */ :

1314

case 0x39 /* '9' */ :

1315

{

1316

mDIGIT(false);

1317

break;

1318

}

1319

case 0x61 /* 'a' */ :

1320

case 0x62 /* 'b' */ :

1321

case 0x63 /* 'c' */ :

1322

case 0x64 /* 'd' */ :

1323

case 0x65 /* 'e' */ :

1324

case 0x66 /* 'f' */ :

1325

{

1326

matchRange('a','f');

1327

break;

1328

}

1329

default:

1330

{

1331

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1332

}

1333

}

1334

}

1335

#line 1956 "ada.g"

1336

lastTokenWasTicCompatible=false;

1337

#line 1338 "AdaLexer.cpp"

1338

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1339

_token = makeToken(_ttype);

1340

_token->setText(text.substr(_begin, text.length()-_begin));

1341

}

1342

_returnToken = _token;

1343

_saveIndex=0;

1344

}

1345

1346

void AdaLexer::mWS_(bool _createToken) {

1347

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1348

_ttype = WS_;

1349

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1350

1351

{

1352

switch ( LA(1)) {

1353

case 0x20 /* ' ' */ :

1354

{

1355

match(' ' /* charlit */ );

1356

break;

1357

}

1358

case 0x9 /* '\t' */ :

1359

{

1360

match('\t' /* charlit */ );

1361

break;

1362

}

1363

case 0xc /* '\14' */ :

1364

{

1365

match('\14' /* charlit */ );

1366

break;

1367

}

1368

case 0xa /* '\n' */ :

1369

case 0xd /* '\r' */ :

1370

{

1371

{

1372

if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {

1373

match("\r\n");

1374

}

1375

else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {

1376

match('\r' /* charlit */ );

1377

}

1378

else if ((LA(1) == 0xa /* '\n' */ )) {

1379

match('\n' /* charlit */ );

1380

}

1381

else {

1382

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1383

}

1384

1385

}

1386

#line 1971 "ada.g"

1387

newline();

1388

#line 1389 "AdaLexer.cpp"

1389

break;

1390

}

1391

default:

1392

{

1393

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1394

}

1395

}

1396

}

1397

#line 1973 "ada.g"

1398

_ttype = antlr::Token::SKIP;

1399

#line 1400 "AdaLexer.cpp"

1400

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1401

_token = makeToken(_ttype);

1402

_token->setText(text.substr(_begin, text.length()-_begin));

1403

}

1404

_returnToken = _token;

1405

_saveIndex=0;

1406

}

1407

1408

void AdaLexer::mCOMMENT(bool _createToken) {

1409

int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();

1410

_ttype = COMMENT;

1411

ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;

1412

1413

mCOMMENT_INTRO(false);

1414

{ // ( ... )*

1415

for (;;) {

1416

if ((_tokenSet_3.member(LA(1)))) {

1417

{

1418

match(_tokenSet_3);

1419

}

1420

}

1421

else {

1422

goto _loop557;

1423

}

1424

1425

}

1426

_loop557:;

1427

} // ( ... )*

1428

{

1429

switch ( LA(1)) {

1430

case 0xa /* '\n' */ :

1431

{

1432

match('\n' /* charlit */ );

1433

break;

1434

}

1435

case 0xd /* '\r' */ :

1436

{

1437

match('\r' /* charlit */ );

1438

{

1439

if ((LA(1) == 0xa /* '\n' */ )) {

1440

match('\n' /* charlit */ );

1441

}

1442

else {

1443

}

1444

1445

}

1446

break;

1447

}

1448

default:

1449

{

1450

throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());

1451

}

1452

}

1453

}

1454

#line 1978 "ada.g"

1455

_ttype = antlr::Token::SKIP;

1456

newline();

1457

lastTokenWasTicCompatible=false;

1458

#line 1459 "AdaLexer.cpp"

1459

if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {

1460

_token = makeToken(_ttype);

1461

_token->setText(text.substr(_begin, text.length()-_begin));

1462

}

1463

_returnToken = _token;

1464

_saveIndex=0;

1465

}

1466

1467

1468

const unsigned long AdaLexer::_tokenSet_0_data_[] = { 0UL, 67043328UL, 2147483648UL, 134217726UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };

1469

// 0 1 2 3 4 5 6 7 8 9 _ a b c d e f g h i j k l m n o p q r s t u v w

1470

// x y z

1471

const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_0(_tokenSet_0_data_,10);

1472

const unsigned long AdaLexer::_tokenSet_1_data_[] = { 4294967288UL, 4294967291UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };

1473

// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13

1474

// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $

1475

// % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F

1476

// G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d e f g

1477

// h i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83

1478

// 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91

1479

// 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e 0x9f

1480

// 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac 0xad

1481

// 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba 0xbb

1482

// 0xbc 0xbd 0xbe 0xbf 0xc0 0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 0xc9

1483

// 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7

1484

// 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 0xe2 0xe3 0xe4 0xe5

1485

// 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef 0xf0 0xf1 0xf2 0xf3

1486

// 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff

1487

const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_1(_tokenSet_1_data_,16);

1488

const unsigned long AdaLexer::_tokenSet_2_data_[] = { 0UL, 67043328UL, 2147483648UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };

1489

// 0 1 2 3 4 5 6 7 8 9 _ a b c d e f

1490

const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_2(_tokenSet_2_data_,10);

1491

const unsigned long AdaLexer::_tokenSet_3_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };

1492

// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14

1493

// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ %

1494

// & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G

1495

// H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d e f g h

1496

// i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83

1497

// 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91

1498

// 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e 0x9f

1499

// 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac 0xad

1500

// 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba 0xbb

1501

// 0xbc 0xbd 0xbe 0xbf 0xc0 0xc1 0xc2 0xc3 0xc4 0xc5 0xc6 0xc7 0xc8 0xc9

1502

// 0xca 0xcb 0xcc 0xcd 0xce 0xcf 0xd0 0xd1 0xd2 0xd3 0xd4 0xd5 0xd6 0xd7

1503

// 0xd8 0xd9 0xda 0xdb 0xdc 0xdd 0xde 0xdf 0xe0 0xe1 0xe2 0xe3 0xe4 0xe5

1504

// 0xe6 0xe7 0xe8 0xe9 0xea 0xeb 0xec 0xed 0xee 0xef 0xf0 0xf1 0xf2 0xf3

1505

// 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff

1506

const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_3(_tokenSet_3_data_,16);

1507

Older »