618 lines
25 KiB
Java
618 lines
25 KiB
Java
/*
|
|
* Copyright © 2002 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
* California 95054, U.S.A. All rights reserved. Sun Microsystems, Inc. has
|
|
* intellectual property rights relating to technology embodied in the product
|
|
* that is described in this document. In particular, and without limitation,
|
|
* these intellectual property rights may include one or more of the U.S.
|
|
* patents listed at http://www.sun.com/patents and one or more additional
|
|
* patents or pending patent applications in the U.S. and in other countries.
|
|
* U.S. Government Rights - Commercial software. Government users are subject
|
|
* to the Sun Microsystems, Inc. standard license agreement and applicable
|
|
* provisions of the FAR and its supplements. Use is subject to license terms.
|
|
* Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
|
|
* trademarks of Sun Microsystems, Inc. in the U.S. and other countries. This
|
|
* product is covered and controlled by U.S. Export Control laws and may be
|
|
* subject to the export or import laws in other countries. Nuclear, missile,
|
|
* chemical biological weapons or nuclear maritime end uses or end users,
|
|
* whether direct or indirect, are strictly prohibited. Export or reexport
|
|
* to countries subject to U.S. embargo or to entities identified on U.S.
|
|
* export exclusion lists, including, but not limited to, the denied persons
|
|
* and specially designated nationals lists is strictly prohibited.
|
|
*/
|
|
|
|
package csjavacc.parser;
|
|
|
|
import java.util.*;
|
|
|
|
import csjavacc.struct.CharacterRange;
|
|
import csjavacc.struct.Nfa;
|
|
import csjavacc.struct.RegularExpression;
|
|
|
|
/**
|
|
* Describes character lists.
|
|
*/
|
|
|
|
public class RCharacterList extends RegularExpression {
|
|
|
|
/**
|
|
* This is true if a tilde (~) appears before the character list.
|
|
* Otherwise, this is false.
|
|
*/
|
|
public boolean negated_list = false;
|
|
|
|
/**
|
|
* This is the list of descriptors of the character list. Each vector
|
|
* entry will narrow to either SingleCharacter or to CharacterRange.
|
|
*/
|
|
public java.util.Vector descriptors = new java.util.Vector();
|
|
|
|
static final char[] diffLowerCaseRanges = {
|
|
65, 90, 192, 214, 216, 222, 256, 256, 258, 258, 260, 260, 262, 262, 264, 264,
|
|
266, 266, 268, 268, 270, 270, 272, 272, 274, 274, 276, 276, 278, 278, 280, 280,
|
|
282, 282, 284, 284, 286, 286, 288, 288, 290, 290, 292, 292, 294, 294, 296, 296,
|
|
298, 298, 300, 300, 302, 302, /* new for fixing 1.0.2 */ 304, 304, /* End new */
|
|
306, 306, 308, 308, 310, 310, 313, 313, 315, 315,
|
|
317, 317, 319, 319, 321, 321, 323, 323, 325, 325, 327, 327, 330, 330, 332, 332,
|
|
334, 334, 336, 336, 338, 338, 340, 340, 342, 342, 344, 344, 346, 346, 348, 348,
|
|
350, 350, 352, 352, 354, 354, 356, 356, 358, 358, 360, 360, 362, 362, 364, 364,
|
|
366, 366, 368, 368, 370, 370, 372, 372, 374, 374, 376, 376, 377, 377, 379, 379,
|
|
381, 381, 385, 385, 386, 386, 388, 388, 390, 390, 391, 391,
|
|
/* new for fixing 1.0.2 */ 393, 393, /* End new */ 394, 394, 395, 395,
|
|
/*398, Sreeni fixed for 1.2*/ 399, 399, 400, 400, 401, 401, 403, 403, 404, 404, 406, 406, 407, 407, 408, 408,
|
|
412, 412, 413, 413, 416, 416, 418, 418, 420, 420, 423, 423, 425, 425, 428, 428,
|
|
430, 430, 431, 431, 433, 434, 435, 435, 437, 437, 439, 439, 440, 440, 444, 444,
|
|
452, 452, 453, 453, 455, 455, 456, 456, 458, 458, 459, 459, 461, 461, 463, 463,
|
|
465, 465, 467, 467, 469, 469, 471, 471, 473, 473, 475, 475, 478, 478, 480, 480,
|
|
482, 482, 484, 484, 486, 486, 488, 488, 490, 490, 492, 492, 494, 494, 497, 497,
|
|
498, 498, 500, 500, 506, 506, 508, 508, 510, 510, 512, 512, 514, 514, 516, 516,
|
|
518, 518, 520, 520, 522, 522, 524, 524, 526, 526, 528, 528, 530, 530, 532, 532,
|
|
534, 534, 902, 902, 904, 906, 908, 908, 910, 911, 913, 929, 931, 939, 994, 994,
|
|
996, 996, 998, 998, 1000, 1000, 1002, 1002, 1004, 1004, 1006, 1006, 1025, 1036,
|
|
1038, 1039, 1040, 1040, 1041, 1041, 1042, 1071, 1120, 1120, 1122, 1122,
|
|
1124, 1124, 1126, 1126, 1128, 1128, 1130, 1130, 1132, 1132, 1134, 1134,
|
|
1136, 1136, 1138, 1138, 1140, 1140, 1142, 1142, 1144, 1144, 1146, 1146,
|
|
1148, 1148, 1150, 1150, 1152, 1152, 1168, 1168, 1170, 1170, 1172, 1172,
|
|
1174, 1174, 1176, 1176, 1178, 1178, 1180, 1180, 1182, 1182, 1184, 1184,
|
|
1186, 1186, 1188, 1188, 1190, 1190, 1192, 1192, 1194, 1194, 1196, 1196,
|
|
1198, 1198, 1200, 1200, 1202, 1202, 1204, 1204, 1206, 1206, 1208, 1208,
|
|
1210, 1210, 1212, 1212, 1214, 1214, 1217, 1217, 1219, 1219, 1223, 1223,
|
|
1227, 1227, 1232, 1232, 1234, 1234, 1236, 1236, 1238, 1238, 1240, 1240,
|
|
1242, 1242, 1244, 1244, 1246, 1246, 1248, 1248, 1250, 1250, 1252, 1252,
|
|
1254, 1254, 1256, 1256, 1258, 1258, 1262, 1262, 1264, 1264, 1266, 1266,
|
|
1268, 1268, 1272, 1272, 1329, 1366, 4256, 4293, 7680, 7680, 7682, 7682,
|
|
7684, 7684, 7686, 7686, 7688, 7688, 7690, 7690, 7692, 7692, 7694, 7694,
|
|
7696, 7696, 7698, 7698, 7700, 7700, 7702, 7702, 7704, 7704, 7706, 7706,
|
|
7708, 7708, 7710, 7710, 7712, 7712, 7714, 7714, 7716, 7716, 7718, 7718,
|
|
7720, 7720, 7722, 7722, 7724, 7724, 7726, 7726, 7728, 7728, 7730, 7730,
|
|
7732, 7732, 7734, 7734, 7736, 7736, 7738, 7738, 7740, 7740, 7742, 7742,
|
|
7744, 7744, 7746, 7746, 7748, 7748, 7750, 7750, 7752, 7752, 7754, 7754,
|
|
7756, 7756, 7758, 7758, 7760, 7760, 7762, 7762, 7764, 7764, 7766, 7766,
|
|
7768, 7768, 7770, 7770, 7772, 7772, 7774, 7774, 7776, 7776, 7778, 7778,
|
|
7780, 7780, 7782, 7782, 7784, 7784, 7786, 7786, 7788, 7788, 7790, 7790,
|
|
7792, 7792, 7794, 7794, 7796, 7796, 7798, 7798, 7800, 7800, 7802, 7802,
|
|
7804, 7804, 7806, 7806, 7808, 7808, 7810, 7810, 7812, 7812, 7814, 7814,
|
|
7816, 7816, 7818, 7818, 7820, 7820, 7822, 7822, 7824, 7824, 7826, 7826,
|
|
7828, 7828, 7840, 7840, 7842, 7842, 7844, 7844, 7846, 7846, 7848, 7848,
|
|
7850, 7850, 7852, 7852, 7854, 7854, 7856, 7856, 7858, 7858, 7860, 7860,
|
|
7862, 7862, 7864, 7864, 7866, 7866, 7868, 7868, 7870, 7870, 7872, 7872,
|
|
7874, 7874, 7876, 7876, 7878, 7878, 7880, 7880, 7882, 7882, 7884, 7884,
|
|
7886, 7886, 7888, 7888, 7890, 7890, 7892, 7892, 7894, 7894, 7896, 7896,
|
|
7898, 7898, 7900, 7900, 7902, 7902, 7904, 7904, 7906, 7906, 7908, 7908,
|
|
7910, 7910, 7912, 7912, 7914, 7914, 7916, 7916, 7918, 7918, 7920, 7920,
|
|
7922, 7922, 7924, 7924, 7926, 7926, 7928, 7928, 7944, 7951, 7960, 7965,
|
|
7976, 7983, 7992, 7999, 8008, 8013, 8025, 8025, 8027, 8027, 8029, 8029,
|
|
8031, 8031, 8040, 8047, 8072, 8079, 8088, 8095, 8104, 8111, 8120, 8121,
|
|
8122, 8123, 8124, 8124, 8136, 8139, 8140, 8140, 8152, 8153, 8154, 8155,
|
|
8168, 8169, 8170, 8171, 8172, 8172, 8184, 8185, 8186, 8187, 8188, 8188,
|
|
8544, 8559, 9398, 9423, 65313, 65338, 65339, 0xfffe, 0xffff, 0xffff
|
|
};
|
|
|
|
static final char[] diffUpperCaseRanges = {
|
|
97, 122, 224, 246, 248, 254, 255, 255, 257, 257, 259, 259, 261, 261, 263, 263,
|
|
265, 265, 267, 267, 269, 269, 271, 271, 273, 273, 275, 275, 277, 277, 279, 279,
|
|
281, 281, 283, 283, 285, 285, 287, 287, 289, 289, 291, 291, 293, 293, 295, 295,
|
|
297, 297, 299, 299, 301, 301, 303, 303, 305, 305, 307, 307, 309, 309, 311, 311,
|
|
314, 314, 316, 316, 318, 318, 320, 320, 322, 322, 324, 324, 326, 326, 328, 328,
|
|
331, 331, 333, 333, 335, 335, 337, 337, 339, 339, 341, 341, 343, 343, 345, 345,
|
|
347, 347, 349, 349, 351, 351, 353, 353, 355, 355, 357, 357, 359, 359, 361, 361,
|
|
363, 363, 365, 365, 367, 367, 369, 369, 371, 371, 373, 373, 375, 375, 378, 378,
|
|
380, 380, 382, 382, 383, 383, 387, 387, 389, 389, 392, 392, 396, 396, 402, 402,
|
|
409, 409, 417, 417, 419, 419, 421, 421, 424, 424, 429, 429, 432, 432, 436, 436,
|
|
438, 438, 441, 441, 445, 445, 453, 453, 454, 454, 456, 456, 457, 457, 459, 459,
|
|
460, 460, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474,
|
|
476, 476, 479, 479, 481, 481, 483, 483, 485, 485, 487, 487, 489, 489, 491, 491,
|
|
493, 493, 495, 495, 498, 498, 499, 499, 501, 501, 507, 507, 509, 509, 511, 511,
|
|
513, 513, 515, 515, 517, 517, 519, 519, 521, 521, 523, 523, 525, 525, 527, 527,
|
|
529, 529, 531, 531, 533, 533, 535, 535, 595, 595, 596, 596, 598,
|
|
/* new for fixing 1.0.2 */ 598, 599, /* End new */ 599, /*600, Sreeni fixed for 1.2 */
|
|
601, 601,
|
|
603, 603, 608, 608, 611, 611, 616, 616, 617, 617, 623, 623, 626, 626, 643, 643,
|
|
648, 648, 650, 651, 658, 658, 940, 940, 941, 943, 945, 961,
|
|
/* new for fixing 1.0.2 */ 962, 962, /* End new */ 963, 971, 972, 972,
|
|
973, 974, 976, 976, 977, 977, 981, 981, 982, 982, 995, 995, 997, 997, 999, 999,
|
|
1001, 1001, 1003, 1003, 1005, 1005, 1007, 1007, 1008, 1008, 1009, 1009,
|
|
1072, 1103, 1105, 1116, 1118, 1119, 1121, 1121, 1123, 1123, 1125, 1125,
|
|
1127, 1127, 1129, 1129, 1131, 1131, 1133, 1133, 1135, 1135, 1137, 1137,
|
|
1139, 1139, 1141, 1141, 1143, 1143, 1145, 1145, 1147, 1147, 1149, 1149,
|
|
1151, 1151, 1153, 1153, 1169, 1169, 1171, 1171, 1173, 1173, 1175, 1175,
|
|
1177, 1177, 1179, 1179, 1181, 1181, 1183, 1183, 1185, 1185, 1187, 1187,
|
|
1189, 1189, 1191, 1191, 1193, 1193, 1195, 1195, 1197, 1197, 1199, 1199,
|
|
1201, 1201, 1203, 1203, 1205, 1205, 1207, 1207, 1209, 1209, 1211, 1211,
|
|
1213, 1213, 1215, 1215, 1218, 1218, 1220, 1220, 1224, 1224, 1228, 1228,
|
|
1233, 1233, 1235, 1235, 1237, 1237, 1239, 1239, 1241, 1241, 1243, 1243,
|
|
1245, 1245, 1247, 1247, 1249, 1249, 1251, 1251, 1253, 1253, 1255, 1255,
|
|
1257, 1257, 1259, 1259, 1263, 1263, 1265, 1265, 1267, 1267, 1269, 1269,
|
|
1273, 1273, 1377, 1414, 7681, 7681, 7683, 7683, 7685, 7685, 7687, 7687,
|
|
7689, 7689, 7691, 7691, 7693, 7693, 7695, 7695, 7697, 7697, 7699, 7699,
|
|
7701, 7701, 7703, 7703, 7705, 7705, 7707, 7707, 7709, 7709, 7711, 7711,
|
|
7713, 7713, 7715, 7715, 7717, 7717, 7719, 7719, 7721, 7721, 7723, 7723,
|
|
7725, 7725, 7727, 7727, 7729, 7729, 7731, 7731, 7733, 7733, 7735, 7735,
|
|
7737, 7737, 7739, 7739, 7741, 7741, 7743, 7743, 7745, 7745, 7747, 7747,
|
|
7749, 7749, 7751, 7751, 7753, 7753, 7755, 7755, 7757, 7757, 7759, 7759,
|
|
7761, 7761, 7763, 7763, 7765, 7765, 7767, 7767, 7769, 7769, 7771, 7771,
|
|
7773, 7773, 7775, 7775, 7777, 7777, 7779, 7779, 7781, 7781, 7783, 7783,
|
|
7785, 7785, 7787, 7787, 7789, 7789, 7791, 7791, 7793, 7793, 7795, 7795,
|
|
7797, 7797, 7799, 7799, 7801, 7801, 7803, 7803, 7805, 7805, 7807, 7807,
|
|
7809, 7809, 7811, 7811, 7813, 7813, 7815, 7815, 7817, 7817, 7819, 7819,
|
|
7821, 7821, 7823, 7823, 7825, 7825, 7827, 7827, 7829, 7829, 7841, 7841,
|
|
7843, 7843, 7845, 7845, 7847, 7847, 7849, 7849, 7851, 7851, 7853, 7853,
|
|
7855, 7855, 7857, 7857, 7859, 7859, 7861, 7861, 7863, 7863, 7865, 7865,
|
|
7867, 7867, 7869, 7869, 7871, 7871, 7873, 7873, 7875, 7875, 7877, 7877,
|
|
7879, 7879, 7881, 7881, 7883, 7883, 7885, 7885, 7887, 7887, 7889, 7889,
|
|
7891, 7891, 7893, 7893, 7895, 7895, 7897, 7897, 7899, 7899, 7901, 7901,
|
|
7903, 7903, 7905, 7905, 7907, 7907, 7909, 7909, 7911, 7911, 7913, 7913,
|
|
7915, 7915, 7917, 7917, 7919, 7919, 7921, 7921, 7923, 7923, 7925, 7925,
|
|
7927, 7927, 7929, 7929, 7936, 7943, 7952, 7957, 7968, 7975, 7984, 7991,
|
|
8000, 8005, 8017, 8017, 8019, 8019, 8021, 8021, 8023, 8023, 8032, 8039,
|
|
8048, 8049, 8050, 8053, 8054, 8055, 8056, 8057, 8058, 8059, 8060, 8061,
|
|
8064, 8071, 8080, 8087, 8096, 8103, 8112, 8113, 8115, 8115, 8131, 8131,
|
|
8144, 8145, 8160, 8161, 8165, 8165, 8179, 8179, 8560, 8575, 9424, 9449,
|
|
65345, 65370, 65371, 0xfffe, 0xffff, 0xffff
|
|
};
|
|
|
|
void ToCaseNeutral()
|
|
{
|
|
int cnt = descriptors.size();
|
|
|
|
OuterLoop:
|
|
for (int i = 0; i < cnt; i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char ch = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
|
|
if (ch != Character.toLowerCase(ch))
|
|
descriptors.addElement(new
|
|
SingleCharacter(Character.toLowerCase(ch)));
|
|
if (ch != Character.toUpperCase(ch))
|
|
descriptors.addElement(new
|
|
SingleCharacter(Character.toUpperCase(ch)));
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
int j = 0;
|
|
|
|
/* Add ranges for which lower case is different. */
|
|
for (;;)
|
|
{
|
|
while (l > diffLowerCaseRanges[j])
|
|
j += 2;
|
|
|
|
if (l < diffLowerCaseRanges[j])
|
|
{
|
|
if (r < diffLowerCaseRanges[j])
|
|
break;
|
|
|
|
if (r <= diffLowerCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(Character.toLowerCase(diffLowerCaseRanges[j]),
|
|
(char)(Character.toLowerCase(diffLowerCaseRanges[j]) + r - diffLowerCaseRanges[j])));
|
|
break;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(Character.toLowerCase(diffLowerCaseRanges[j]),
|
|
Character.toLowerCase(diffLowerCaseRanges[j + 1])));
|
|
}
|
|
else
|
|
{
|
|
if (r <= diffLowerCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(
|
|
(char)(Character.toLowerCase(diffLowerCaseRanges[j]) + l - diffLowerCaseRanges[j]),
|
|
(char)(Character.toLowerCase(diffLowerCaseRanges[j]) + r - diffLowerCaseRanges[j])));
|
|
break;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(
|
|
(char)(Character.toLowerCase(diffLowerCaseRanges[j]) + l - diffLowerCaseRanges[j]),
|
|
Character.toLowerCase(diffLowerCaseRanges[j + 1])));
|
|
}
|
|
|
|
j += 2;
|
|
while (r > diffLowerCaseRanges[j])
|
|
{
|
|
if (r <= diffLowerCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(Character.toLowerCase(diffLowerCaseRanges[j]),
|
|
(char)(Character.toLowerCase(diffLowerCaseRanges[j]) + r - diffLowerCaseRanges[j])));
|
|
break;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(Character.toLowerCase(diffLowerCaseRanges[j]),
|
|
Character.toLowerCase(diffLowerCaseRanges[j + 1])));
|
|
j += 2;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* Add ranges for which upper case is different. */
|
|
j = 0;
|
|
while (l > diffUpperCaseRanges[j])
|
|
j += 2;
|
|
|
|
if (l < diffUpperCaseRanges[j])
|
|
{
|
|
if (r < diffUpperCaseRanges[j])
|
|
continue;
|
|
|
|
if (r <= diffUpperCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(Character.toUpperCase(diffUpperCaseRanges[j]),
|
|
(char)(Character.toUpperCase(diffUpperCaseRanges[j]) + r - diffUpperCaseRanges[j])));
|
|
continue;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(Character.toUpperCase(diffUpperCaseRanges[j]),
|
|
Character.toUpperCase(diffUpperCaseRanges[j + 1])));
|
|
}
|
|
else
|
|
{
|
|
if (r <= diffUpperCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(
|
|
(char)(Character.toUpperCase(diffUpperCaseRanges[j]) + l - diffUpperCaseRanges[j]),
|
|
(char)(Character.toUpperCase(diffUpperCaseRanges[j]) + r - diffUpperCaseRanges[j])));
|
|
continue;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(
|
|
(char)(Character.toUpperCase(diffUpperCaseRanges[j]) + l - diffUpperCaseRanges[j]),
|
|
Character.toUpperCase(diffUpperCaseRanges[j + 1])));
|
|
}
|
|
|
|
j += 2;
|
|
while (r > diffUpperCaseRanges[j])
|
|
{
|
|
if (r <= diffUpperCaseRanges[j + 1])
|
|
{
|
|
descriptors.addElement(new CharacterRange(Character.toUpperCase(diffUpperCaseRanges[j]),
|
|
(char)(Character.toUpperCase(diffUpperCaseRanges[j]) + r - diffUpperCaseRanges[j])));
|
|
break;
|
|
}
|
|
|
|
descriptors.addElement(new CharacterRange(Character.toUpperCase(diffUpperCaseRanges[j]),
|
|
Character.toUpperCase(diffUpperCaseRanges[j + 1])));
|
|
j += 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean transformed = false;
|
|
public Nfa GenerateNfa(boolean ignoreCase)
|
|
{
|
|
if (!transformed)
|
|
{
|
|
if (Options.getIgnoreCase() || ignoreCase)
|
|
{
|
|
/*
|
|
int i;
|
|
System.err.println("Before:");
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
System.err.print((int)c + " ");
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
|
|
System.err.print((int)l + "-" + (int)r + " ");
|
|
}
|
|
if ((i + 1) % 6 == 0)
|
|
System.err.println("");
|
|
}
|
|
System.err.println("");
|
|
*/
|
|
|
|
ToCaseNeutral();
|
|
SortDescriptors();
|
|
|
|
/*
|
|
System.err.println("After:");
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
System.err.print((int)c + " ");
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
|
|
System.err.print((int)l + "-" + (int)r + " ");
|
|
}
|
|
if ((i + 1) % 6 == 0)
|
|
System.err.println("");
|
|
}
|
|
System.err.println("");
|
|
*/
|
|
}
|
|
|
|
if (negated_list)
|
|
RemoveNegation(); // This also sorts the list
|
|
else
|
|
SortDescriptors();
|
|
}
|
|
|
|
transformed = true;
|
|
Nfa retVal = new Nfa();
|
|
NfaState startState = retVal.start;
|
|
NfaState finalState = retVal.end;
|
|
int i;
|
|
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
startState.AddChar(((SingleCharacter)descriptors.elementAt(i)).ch);
|
|
else // if (descriptors.elementAt(i) instanceof CharacterRange)
|
|
{
|
|
CharacterRange cr = (CharacterRange)descriptors.elementAt(i);
|
|
|
|
if (cr.left == cr.right)
|
|
startState.AddChar(cr.left);
|
|
else
|
|
startState.AddRange(cr.left, cr.right);
|
|
}
|
|
}
|
|
|
|
startState.next = finalState;
|
|
|
|
return retVal;
|
|
}
|
|
|
|
static boolean Overlaps(CharacterRange r1, CharacterRange r2)
|
|
{
|
|
return (r1.left <= r2.right && r1.right > r2.right);
|
|
}
|
|
|
|
static boolean SubRange(CharacterRange r1, CharacterRange r2)
|
|
{
|
|
return (r1.left >= r2.left && r1.right <= r2.right);
|
|
}
|
|
|
|
static boolean InRange(char c, CharacterRange range)
|
|
{
|
|
return (c >= range.left && c <= range.right);
|
|
}
|
|
|
|
void SortDescriptors()
|
|
{
|
|
int j;
|
|
|
|
Vector newDesc = new Vector(descriptors.size());
|
|
int cnt = 0;
|
|
|
|
Outer:
|
|
for (int i = 0; i < descriptors.size(); i++)
|
|
{
|
|
SingleCharacter s;
|
|
CharacterRange range;
|
|
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
s = (SingleCharacter)descriptors.elementAt(i);
|
|
|
|
for (j = 0; j < cnt; j++)
|
|
{
|
|
if (newDesc.elementAt(j) instanceof SingleCharacter)
|
|
{
|
|
if (((SingleCharacter)newDesc.elementAt(j)).ch > s.ch)
|
|
break;
|
|
else if (((SingleCharacter)newDesc.elementAt(j)).ch == s.ch)
|
|
continue Outer;
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)newDesc.elementAt(j)).left;
|
|
|
|
if (InRange(s.ch, (CharacterRange)newDesc.elementAt(j)))
|
|
continue Outer;
|
|
else if (l > s.ch)
|
|
break;
|
|
}
|
|
}
|
|
|
|
newDesc.insertElementAt(s, j);
|
|
cnt++;
|
|
}
|
|
else
|
|
{
|
|
range = (CharacterRange)descriptors.elementAt(i);
|
|
|
|
for (j = 0; j < cnt; j++)
|
|
{
|
|
if (newDesc.elementAt(j) instanceof SingleCharacter)
|
|
{
|
|
if (InRange(((SingleCharacter)newDesc.elementAt(j)).ch, range))
|
|
{
|
|
newDesc.removeElementAt(j--);
|
|
cnt--;
|
|
}
|
|
else if (((SingleCharacter)newDesc.elementAt(j)).ch > range.right)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (SubRange(range, (CharacterRange)newDesc.elementAt(j)))
|
|
{
|
|
continue Outer;
|
|
}
|
|
else if (SubRange((CharacterRange)newDesc.elementAt(j), range))
|
|
{
|
|
newDesc.setElementAt(range, j);
|
|
continue Outer;
|
|
}
|
|
else if (Overlaps(range, (CharacterRange)newDesc.elementAt(j)))
|
|
{
|
|
range.left = (char)(((CharacterRange)newDesc.elementAt(j)).right + 1);
|
|
}
|
|
else if (Overlaps((CharacterRange)newDesc.elementAt(j), range))
|
|
{
|
|
CharacterRange tmp = range;
|
|
((CharacterRange)newDesc.elementAt(j)).right = (char)(range.left + 1);
|
|
range = (CharacterRange)newDesc.elementAt(j);
|
|
newDesc.setElementAt(tmp, j);
|
|
}
|
|
else if (((CharacterRange)newDesc.elementAt(j)).left > range.right)
|
|
break;
|
|
}
|
|
}
|
|
|
|
newDesc.insertElementAt(range, j);
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
newDesc.trimToSize();
|
|
descriptors = newDesc;
|
|
}
|
|
|
|
void RemoveNegation()
|
|
{
|
|
int i;
|
|
|
|
SortDescriptors();
|
|
|
|
/*
|
|
System.err.println("REM. NEG Before:");
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
System.err.print((int)c + " ");
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
|
|
System.err.print((int)l + "-" + (int)r + " ");
|
|
}
|
|
}
|
|
System.err.println("");
|
|
*/
|
|
|
|
Vector newDescriptors = new Vector();
|
|
int lastRemoved = -1; // One less than the first valid character.
|
|
|
|
OuterLoop:
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
|
|
if (c >= 0 && c <= lastRemoved + 1)
|
|
{
|
|
lastRemoved = c;
|
|
continue;
|
|
}
|
|
|
|
//System.err.println("lastRemoved : " + (int)lastRemoved + "; char : " + (int)c);
|
|
newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
|
|
(char)((lastRemoved = c) - 1)));
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
|
|
if (l >= 0 && l <= lastRemoved + 1)
|
|
{
|
|
lastRemoved = r;
|
|
continue;
|
|
}
|
|
|
|
//System.err.println("lastRemoved : " + (int)lastRemoved + "; left : " + l + "; right : " + (int)r);
|
|
newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
|
|
(char)(l - 1)));
|
|
lastRemoved = r;
|
|
}
|
|
}
|
|
|
|
//System.err.println("lastRem : " + (int)lastRemoved);
|
|
if (NfaState.unicodeWarningGiven || Options.getCSUnicodeEscape())
|
|
{
|
|
if (lastRemoved < (char)0xffff)
|
|
newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
|
|
(char)0xffff));
|
|
}
|
|
else
|
|
{
|
|
if (lastRemoved < (char)0xff)
|
|
newDescriptors.addElement(new CharacterRange((char)(lastRemoved + 1),
|
|
(char)0xff));
|
|
}
|
|
|
|
descriptors = newDescriptors;
|
|
negated_list = false;
|
|
|
|
/*
|
|
System.err.println("REM NEG After:");
|
|
for (i = 0; i < descriptors.size(); i++)
|
|
{
|
|
if (descriptors.elementAt(i) instanceof SingleCharacter)
|
|
{
|
|
char c = ((SingleCharacter)descriptors.elementAt(i)).ch;
|
|
System.err.print((int)c + " ");
|
|
}
|
|
else
|
|
{
|
|
char l = ((CharacterRange)descriptors.elementAt(i)).left;
|
|
char r = ((CharacterRange)descriptors.elementAt(i)).right;
|
|
|
|
System.err.print((int)l + "-" + (int)r + " ");
|
|
}
|
|
}
|
|
System.err.println("");
|
|
*/
|
|
}
|
|
|
|
public RCharacterList()
|
|
{
|
|
}
|
|
|
|
public RCharacterList(char c)
|
|
{
|
|
descriptors = new Vector();
|
|
descriptors.addElement(new SingleCharacter(c));
|
|
negated_list = false;
|
|
ordinal = Integer.MAX_VALUE;
|
|
}
|
|
|
|
public boolean CanMatchAnyChar()
|
|
{
|
|
// Return true only if it is ~[]
|
|
return negated_list && (descriptors == null || descriptors.size() == 0);
|
|
}
|
|
}
|